plan.pb.h - OpenGrok cross reference for /aosp_15_r20/out/soong/.intermediates/external/federated-compute/federated-compute-cc-proto-lite/android_arm64_armv8-2a_cortex-a55_static_apex33/gen/proto/fcp/protos/plan.pb.h

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: fcp/protos/plan.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_fcp_2fprotos_2fplan_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_fcp_2fprotos_2fplan_2eproto

#include <cstdint>
#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#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 3021012 < 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/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/message_lite.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/map.h>  // IWYU pragma: export
#include <google/protobuf/map_entry_lite.h>
#include <google/protobuf/map_field_lite.h>
#include <google/protobuf/generated_enum_util.h>
#include <google/protobuf/any.pb.h>
#include "tensorflow/core/framework/tensor.pb.h"
#include "tensorflow/core/framework/types.pb.h"
#include "tensorflow/core/protobuf/saver.pb.h"
#include "tensorflow/core/protobuf/struct.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_fcp_2fprotos_2fplan_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_fcp_2fprotos_2fplan_2eproto {
  static const ::uint32_t offsets[];
};
namespace google {
namespace internal {
namespace federated {
namespace plan {
class AggregationConfig;
struct AggregationConfigDefaultTypeInternal;
extern AggregationConfigDefaultTypeInternal _AggregationConfig_default_instance_;
class AsyncInputFeed;
struct AsyncInputFeedDefaultTypeInternal;
extern AsyncInputFeedDefaultTypeInternal _AsyncInputFeed_default_instance_;
class AverageOptions;
struct AverageOptionsDefaultTypeInternal;
extern AverageOptionsDefaultTypeInternal _AverageOptions_default_instance_;
class CheckpointOp;
struct CheckpointOpDefaultTypeInternal;
extern CheckpointOpDefaultTypeInternal _CheckpointOp_default_instance_;
class CheckpointOp_SideChannelTensorsEntry_DoNotUse;
struct CheckpointOp_SideChannelTensorsEntry_DoNotUseDefaultTypeInternal;
extern CheckpointOp_SideChannelTensorsEntry_DoNotUseDefaultTypeInternal _CheckpointOp_SideChannelTensorsEntry_DoNotUse_default_instance_;
class ClientOnlyPlan;
struct ClientOnlyPlanDefaultTypeInternal;
extern ClientOnlyPlanDefaultTypeInternal _ClientOnlyPlan_default_instance_;
class ClientPhase;
struct ClientPhaseDefaultTypeInternal;
extern ClientPhaseDefaultTypeInternal _ClientPhase_default_instance_;
class CrossRoundAggregationExecution;
struct CrossRoundAggregationExecutionDefaultTypeInternal;
extern CrossRoundAggregationExecutionDefaultTypeInternal _CrossRoundAggregationExecution_default_instance_;
class Dataset;
struct DatasetDefaultTypeInternal;
extern DatasetDefaultTypeInternal _Dataset_default_instance_;
class DatasetInput;
struct DatasetInputDefaultTypeInternal;
extern DatasetInputDefaultTypeInternal _DatasetInput_default_instance_;
class DatasetInputPlaceholders;
struct DatasetInputPlaceholdersDefaultTypeInternal;
extern DatasetInputPlaceholdersDefaultTypeInternal _DatasetInputPlaceholders_default_instance_;
class Dataset_ClientDataset;
struct Dataset_ClientDatasetDefaultTypeInternal;
extern Dataset_ClientDatasetDefaultTypeInternal _Dataset_ClientDataset_default_instance_;
class Dataset_ClientDataset_SelectedExample;
struct Dataset_ClientDataset_SelectedExampleDefaultTypeInternal;
extern Dataset_ClientDataset_SelectedExampleDefaultTypeInternal _Dataset_ClientDataset_SelectedExample_default_instance_;
class ExampleQuerySpec;
struct ExampleQuerySpecDefaultTypeInternal;
extern ExampleQuerySpecDefaultTypeInternal _ExampleQuerySpec_default_instance_;
class ExampleQuerySpec_ExampleQuery;
struct ExampleQuerySpec_ExampleQueryDefaultTypeInternal;
extern ExampleQuerySpec_ExampleQueryDefaultTypeInternal _ExampleQuerySpec_ExampleQuery_default_instance_;
class ExampleQuerySpec_ExampleQuery_OutputVectorSpecsEntry_DoNotUse;
struct ExampleQuerySpec_ExampleQuery_OutputVectorSpecsEntry_DoNotUseDefaultTypeInternal;
extern ExampleQuerySpec_ExampleQuery_OutputVectorSpecsEntry_DoNotUseDefaultTypeInternal _ExampleQuerySpec_ExampleQuery_OutputVectorSpecsEntry_DoNotUse_default_instance_;
class ExampleQuerySpec_OutputVectorSpec;
struct ExampleQuerySpec_OutputVectorSpecDefaultTypeInternal;
extern ExampleQuerySpec_OutputVectorSpecDefaultTypeInternal _ExampleQuerySpec_OutputVectorSpec_default_instance_;
class ExampleSelector;
struct ExampleSelectorDefaultTypeInternal;
extern ExampleSelectorDefaultTypeInternal _ExampleSelector_default_instance_;
class FederatedComputeEligibilityIORouter;
struct FederatedComputeEligibilityIORouterDefaultTypeInternal;
extern FederatedComputeEligibilityIORouterDefaultTypeInternal _FederatedComputeEligibilityIORouter_default_instance_;
class FederatedComputeIORouter;
struct FederatedComputeIORouterDefaultTypeInternal;
extern FederatedComputeIORouterDefaultTypeInternal _FederatedComputeIORouter_default_instance_;
class FederatedComputeIORouter_AggregationsEntry_DoNotUse;
struct FederatedComputeIORouter_AggregationsEntry_DoNotUseDefaultTypeInternal;
extern FederatedComputeIORouter_AggregationsEntry_DoNotUseDefaultTypeInternal _FederatedComputeIORouter_AggregationsEntry_DoNotUse_default_instance_;
class FederatedExampleQueryIORouter;
struct FederatedExampleQueryIORouterDefaultTypeInternal;
extern FederatedExampleQueryIORouterDefaultTypeInternal _FederatedExampleQueryIORouter_default_instance_;
class FederatedExampleQueryIORouter_AggregationsEntry_DoNotUse;
struct FederatedExampleQueryIORouter_AggregationsEntry_DoNotUseDefaultTypeInternal;
extern FederatedExampleQueryIORouter_AggregationsEntry_DoNotUseDefaultTypeInternal _FederatedExampleQueryIORouter_AggregationsEntry_DoNotUse_default_instance_;
class LocalComputeIORouter;
struct LocalComputeIORouterDefaultTypeInternal;
extern LocalComputeIORouterDefaultTypeInternal _LocalComputeIORouter_default_instance_;
class Measurement;
struct MeasurementDefaultTypeInternal;
extern MeasurementDefaultTypeInternal _Measurement_default_instance_;
class Metric;
struct MetricDefaultTypeInternal;
extern MetricDefaultTypeInternal _Metric_default_instance_;
class MetricTestPredicates;
struct MetricTestPredicatesDefaultTypeInternal;
extern MetricTestPredicatesDefaultTypeInternal _MetricTestPredicates_default_instance_;
class MetricTestPredicates_Interval;
struct MetricTestPredicates_IntervalDefaultTypeInternal;
extern MetricTestPredicates_IntervalDefaultTypeInternal _MetricTestPredicates_Interval_default_instance_;
class MetricTestPredicates_MetricCriterion;
struct MetricTestPredicates_MetricCriterionDefaultTypeInternal;
extern MetricTestPredicates_MetricCriterionDefaultTypeInternal _MetricTestPredicates_MetricCriterion_default_instance_;
class MetricTestPredicates_RealIfNonzeroWeight;
struct MetricTestPredicates_RealIfNonzeroWeightDefaultTypeInternal;
extern MetricTestPredicates_RealIfNonzeroWeightDefaultTypeInternal _MetricTestPredicates_RealIfNonzeroWeight_default_instance_;
class MultipleInputResources;
struct MultipleInputResourcesDefaultTypeInternal;
extern MultipleInputResourcesDefaultTypeInternal _MultipleInputResources_default_instance_;
class MultipleInputResources_InputResourceTensorNameMapEntry_DoNotUse;
struct MultipleInputResources_InputResourceTensorNameMapEntry_DoNotUseDefaultTypeInternal;
extern MultipleInputResources_InputResourceTensorNameMapEntry_DoNotUseDefaultTypeInternal _MultipleInputResources_InputResourceTensorNameMapEntry_DoNotUse_default_instance_;
class NoneOptions;
struct NoneOptionsDefaultTypeInternal;
extern NoneOptionsDefaultTypeInternal _NoneOptions_default_instance_;
class OnlySampleOptions;
struct OnlySampleOptionsDefaultTypeInternal;
extern OnlySampleOptionsDefaultTypeInternal _OnlySampleOptions_default_instance_;
class OutputMetric;
struct OutputMetricDefaultTypeInternal;
extern OutputMetricDefaultTypeInternal _OutputMetric_default_instance_;
class Plan;
struct PlanDefaultTypeInternal;
extern PlanDefaultTypeInternal _Plan_default_instance_;
class Plan_Phase;
struct Plan_PhaseDefaultTypeInternal;
extern Plan_PhaseDefaultTypeInternal _Plan_Phase_default_instance_;
class SecureAggregationConfig;
struct SecureAggregationConfigDefaultTypeInternal;
extern SecureAggregationConfigDefaultTypeInternal _SecureAggregationConfig_default_instance_;
class ServerAggregationConfig;
struct ServerAggregationConfigDefaultTypeInternal;
extern ServerAggregationConfigDefaultTypeInternal _ServerAggregationConfig_default_instance_;
class ServerAggregationConfig_IntrinsicArg;
struct ServerAggregationConfig_IntrinsicArgDefaultTypeInternal;
extern ServerAggregationConfig_IntrinsicArgDefaultTypeInternal _ServerAggregationConfig_IntrinsicArg_default_instance_;
class ServerEligibilityComputationPhase;
struct ServerEligibilityComputationPhaseDefaultTypeInternal;
extern ServerEligibilityComputationPhaseDefaultTypeInternal _ServerEligibilityComputationPhase_default_instance_;
class ServerPhase;
struct ServerPhaseDefaultTypeInternal;
extern ServerPhaseDefaultTypeInternal _ServerPhase_default_instance_;
class ServerPhaseV2;
struct ServerPhaseV2DefaultTypeInternal;
extern ServerPhaseV2DefaultTypeInternal _ServerPhaseV2_default_instance_;
class ServerPrepareIORouter;
struct ServerPrepareIORouterDefaultTypeInternal;
extern ServerPrepareIORouterDefaultTypeInternal _ServerPrepareIORouter_default_instance_;
class ServerResultIORouter;
struct ServerResultIORouterDefaultTypeInternal;
extern ServerResultIORouterDefaultTypeInternal _ServerResultIORouter_default_instance_;
class SideChannel;
struct SideChannelDefaultTypeInternal;
extern SideChannelDefaultTypeInternal _SideChannel_default_instance_;
class SideChannel_SecureAggregand;
struct SideChannel_SecureAggregandDefaultTypeInternal;
extern SideChannel_SecureAggregandDefaultTypeInternal _SideChannel_SecureAggregand_default_instance_;
class SideChannel_SecureAggregand_Dimension;
struct SideChannel_SecureAggregand_DimensionDefaultTypeInternal;
extern SideChannel_SecureAggregand_DimensionDefaultTypeInternal _SideChannel_SecureAggregand_Dimension_default_instance_;
class SideChannel_SecureAggregand_FixedModulus;
struct SideChannel_SecureAggregand_FixedModulusDefaultTypeInternal;
extern SideChannel_SecureAggregand_FixedModulusDefaultTypeInternal _SideChannel_SecureAggregand_FixedModulus_default_instance_;
class SideChannel_SecureAggregand_ModulusTimesShardSize;
struct SideChannel_SecureAggregand_ModulusTimesShardSizeDefaultTypeInternal;
extern SideChannel_SecureAggregand_ModulusTimesShardSizeDefaultTypeInternal _SideChannel_SecureAggregand_ModulusTimesShardSize_default_instance_;
class SlicesSelector;
struct SlicesSelectorDefaultTypeInternal;
extern SlicesSelectorDefaultTypeInternal _SlicesSelector_default_instance_;
class SlicesTestData;
struct SlicesTestDataDefaultTypeInternal;
extern SlicesTestDataDefaultTypeInternal _SlicesTestData_default_instance_;
class SlicesTestDataset;
struct SlicesTestDatasetDefaultTypeInternal;
extern SlicesTestDatasetDefaultTypeInternal _SlicesTestDataset_default_instance_;
class SlicesTestDataset_DatasetEntry_DoNotUse;
struct SlicesTestDataset_DatasetEntry_DoNotUseDefaultTypeInternal;
extern SlicesTestDataset_DatasetEntry_DoNotUseDefaultTypeInternal _SlicesTestDataset_DatasetEntry_DoNotUse_default_instance_;
class SumOptions;
struct SumOptionsDefaultTypeInternal;
extern SumOptionsDefaultTypeInternal _SumOptions_default_instance_;
class TEContextServerEligibilityIORouter;
struct TEContextServerEligibilityIORouterDefaultTypeInternal;
extern TEContextServerEligibilityIORouterDefaultTypeInternal _TEContextServerEligibilityIORouter_default_instance_;
class TFV1CheckpointAggregation;
struct TFV1CheckpointAggregationDefaultTypeInternal;
extern TFV1CheckpointAggregationDefaultTypeInternal _TFV1CheckpointAggregation_default_instance_;
class TensorflowSpec;
struct TensorflowSpecDefaultTypeInternal;
extern TensorflowSpecDefaultTypeInternal _TensorflowSpec_default_instance_;
class TensorflowSpec_ConstantInputsEntry_DoNotUse;
struct TensorflowSpec_ConstantInputsEntry_DoNotUseDefaultTypeInternal;
extern TensorflowSpec_ConstantInputsEntry_DoNotUseDefaultTypeInternal _TensorflowSpec_ConstantInputsEntry_DoNotUse_default_instance_;
class VisualizationSpec;
struct VisualizationSpecDefaultTypeInternal;
extern VisualizationSpecDefaultTypeInternal _VisualizationSpec_default_instance_;
}  // namespace plan
}  // namespace federated
}  // namespace internal
}  // namespace google
PROTOBUF_NAMESPACE_OPEN
template<> ::google::internal::federated::plan::AggregationConfig* Arena::CreateMaybeMessage<::google::internal::federated::plan::AggregationConfig>(Arena*);
template<> ::google::internal::federated::plan::AsyncInputFeed* Arena::CreateMaybeMessage<::google::internal::federated::plan::AsyncInputFeed>(Arena*);
template<> ::google::internal::federated::plan::AverageOptions* Arena::CreateMaybeMessage<::google::internal::federated::plan::AverageOptions>(Arena*);
template<> ::google::internal::federated::plan::CheckpointOp* Arena::CreateMaybeMessage<::google::internal::federated::plan::CheckpointOp>(Arena*);
template<> ::google::internal::federated::plan::CheckpointOp_SideChannelTensorsEntry_DoNotUse* Arena::CreateMaybeMessage<::google::internal::federated::plan::CheckpointOp_SideChannelTensorsEntry_DoNotUse>(Arena*);
template<> ::google::internal::federated::plan::ClientOnlyPlan* Arena::CreateMaybeMessage<::google::internal::federated::plan::ClientOnlyPlan>(Arena*);
template<> ::google::internal::federated::plan::ClientPhase* Arena::CreateMaybeMessage<::google::internal::federated::plan::ClientPhase>(Arena*);
template<> ::google::internal::federated::plan::CrossRoundAggregationExecution* Arena::CreateMaybeMessage<::google::internal::federated::plan::CrossRoundAggregationExecution>(Arena*);
template<> ::google::internal::federated::plan::Dataset* Arena::CreateMaybeMessage<::google::internal::federated::plan::Dataset>(Arena*);
template<> ::google::internal::federated::plan::DatasetInput* Arena::CreateMaybeMessage<::google::internal::federated::plan::DatasetInput>(Arena*);
template<> ::google::internal::federated::plan::DatasetInputPlaceholders* Arena::CreateMaybeMessage<::google::internal::federated::plan::DatasetInputPlaceholders>(Arena*);
template<> ::google::internal::federated::plan::Dataset_ClientDataset* Arena::CreateMaybeMessage<::google::internal::federated::plan::Dataset_ClientDataset>(Arena*);
template<> ::google::internal::federated::plan::Dataset_ClientDataset_SelectedExample* Arena::CreateMaybeMessage<::google::internal::federated::plan::Dataset_ClientDataset_SelectedExample>(Arena*);
template<> ::google::internal::federated::plan::ExampleQuerySpec* Arena::CreateMaybeMessage<::google::internal::federated::plan::ExampleQuerySpec>(Arena*);
template<> ::google::internal::federated::plan::ExampleQuerySpec_ExampleQuery* Arena::CreateMaybeMessage<::google::internal::federated::plan::ExampleQuerySpec_ExampleQuery>(Arena*);
template<> ::google::internal::federated::plan::ExampleQuerySpec_ExampleQuery_OutputVectorSpecsEntry_DoNotUse* Arena::CreateMaybeMessage<::google::internal::federated::plan::ExampleQuerySpec_ExampleQuery_OutputVectorSpecsEntry_DoNotUse>(Arena*);
template<> ::google::internal::federated::plan::ExampleQuerySpec_OutputVectorSpec* Arena::CreateMaybeMessage<::google::internal::federated::plan::ExampleQuerySpec_OutputVectorSpec>(Arena*);
template<> ::google::internal::federated::plan::ExampleSelector* Arena::CreateMaybeMessage<::google::internal::federated::plan::ExampleSelector>(Arena*);
template<> ::google::internal::federated::plan::FederatedComputeEligibilityIORouter* Arena::CreateMaybeMessage<::google::internal::federated::plan::FederatedComputeEligibilityIORouter>(Arena*);
template<> ::google::internal::federated::plan::FederatedComputeIORouter* Arena::CreateMaybeMessage<::google::internal::federated::plan::FederatedComputeIORouter>(Arena*);
template<> ::google::internal::federated::plan::FederatedComputeIORouter_AggregationsEntry_DoNotUse* Arena::CreateMaybeMessage<::google::internal::federated::plan::FederatedComputeIORouter_AggregationsEntry_DoNotUse>(Arena*);
template<> ::google::internal::federated::plan::FederatedExampleQueryIORouter* Arena::CreateMaybeMessage<::google::internal::federated::plan::FederatedExampleQueryIORouter>(Arena*);
template<> ::google::internal::federated::plan::FederatedExampleQueryIORouter_AggregationsEntry_DoNotUse* Arena::CreateMaybeMessage<::google::internal::federated::plan::FederatedExampleQueryIORouter_AggregationsEntry_DoNotUse>(Arena*);
template<> ::google::internal::federated::plan::LocalComputeIORouter* Arena::CreateMaybeMessage<::google::internal::federated::plan::LocalComputeIORouter>(Arena*);
template<> ::google::internal::federated::plan::Measurement* Arena::CreateMaybeMessage<::google::internal::federated::plan::Measurement>(Arena*);
template<> ::google::internal::federated::plan::Metric* Arena::CreateMaybeMessage<::google::internal::federated::plan::Metric>(Arena*);
template<> ::google::internal::federated::plan::MetricTestPredicates* Arena::CreateMaybeMessage<::google::internal::federated::plan::MetricTestPredicates>(Arena*);
template<> ::google::internal::federated::plan::MetricTestPredicates_Interval* Arena::CreateMaybeMessage<::google::internal::federated::plan::MetricTestPredicates_Interval>(Arena*);
template<> ::google::internal::federated::plan::MetricTestPredicates_MetricCriterion* Arena::CreateMaybeMessage<::google::internal::federated::plan::MetricTestPredicates_MetricCriterion>(Arena*);
template<> ::google::internal::federated::plan::MetricTestPredicates_RealIfNonzeroWeight* Arena::CreateMaybeMessage<::google::internal::federated::plan::MetricTestPredicates_RealIfNonzeroWeight>(Arena*);
template<> ::google::internal::federated::plan::MultipleInputResources* Arena::CreateMaybeMessage<::google::internal::federated::plan::MultipleInputResources>(Arena*);
template<> ::google::internal::federated::plan::MultipleInputResources_InputResourceTensorNameMapEntry_DoNotUse* Arena::CreateMaybeMessage<::google::internal::federated::plan::MultipleInputResources_InputResourceTensorNameMapEntry_DoNotUse>(Arena*);
template<> ::google::internal::federated::plan::NoneOptions* Arena::CreateMaybeMessage<::google::internal::federated::plan::NoneOptions>(Arena*);
template<> ::google::internal::federated::plan::OnlySampleOptions* Arena::CreateMaybeMessage<::google::internal::federated::plan::OnlySampleOptions>(Arena*);
template<> ::google::internal::federated::plan::OutputMetric* Arena::CreateMaybeMessage<::google::internal::federated::plan::OutputMetric>(Arena*);
template<> ::google::internal::federated::plan::Plan* Arena::CreateMaybeMessage<::google::internal::federated::plan::Plan>(Arena*);
template<> ::google::internal::federated::plan::Plan_Phase* Arena::CreateMaybeMessage<::google::internal::federated::plan::Plan_Phase>(Arena*);
template<> ::google::internal::federated::plan::SecureAggregationConfig* Arena::CreateMaybeMessage<::google::internal::federated::plan::SecureAggregationConfig>(Arena*);
template<> ::google::internal::federated::plan::ServerAggregationConfig* Arena::CreateMaybeMessage<::google::internal::federated::plan::ServerAggregationConfig>(Arena*);
template<> ::google::internal::federated::plan::ServerAggregationConfig_IntrinsicArg* Arena::CreateMaybeMessage<::google::internal::federated::plan::ServerAggregationConfig_IntrinsicArg>(Arena*);
template<> ::google::internal::federated::plan::ServerEligibilityComputationPhase* Arena::CreateMaybeMessage<::google::internal::federated::plan::ServerEligibilityComputationPhase>(Arena*);
template<> ::google::internal::federated::plan::ServerPhase* Arena::CreateMaybeMessage<::google::internal::federated::plan::ServerPhase>(Arena*);
template<> ::google::internal::federated::plan::ServerPhaseV2* Arena::CreateMaybeMessage<::google::internal::federated::plan::ServerPhaseV2>(Arena*);
template<> ::google::internal::federated::plan::ServerPrepareIORouter* Arena::CreateMaybeMessage<::google::internal::federated::plan::ServerPrepareIORouter>(Arena*);
template<> ::google::internal::federated::plan::ServerResultIORouter* Arena::CreateMaybeMessage<::google::internal::federated::plan::ServerResultIORouter>(Arena*);
template<> ::google::internal::federated::plan::SideChannel* Arena::CreateMaybeMessage<::google::internal::federated::plan::SideChannel>(Arena*);
template<> ::google::internal::federated::plan::SideChannel_SecureAggregand* Arena::CreateMaybeMessage<::google::internal::federated::plan::SideChannel_SecureAggregand>(Arena*);
template<> ::google::internal::federated::plan::SideChannel_SecureAggregand_Dimension* Arena::CreateMaybeMessage<::google::internal::federated::plan::SideChannel_SecureAggregand_Dimension>(Arena*);
template<> ::google::internal::federated::plan::SideChannel_SecureAggregand_FixedModulus* Arena::CreateMaybeMessage<::google::internal::federated::plan::SideChannel_SecureAggregand_FixedModulus>(Arena*);
template<> ::google::internal::federated::plan::SideChannel_SecureAggregand_ModulusTimesShardSize* Arena::CreateMaybeMessage<::google::internal::federated::plan::SideChannel_SecureAggregand_ModulusTimesShardSize>(Arena*);
template<> ::google::internal::federated::plan::SlicesSelector* Arena::CreateMaybeMessage<::google::internal::federated::plan::SlicesSelector>(Arena*);
template<> ::google::internal::federated::plan::SlicesTestData* Arena::CreateMaybeMessage<::google::internal::federated::plan::SlicesTestData>(Arena*);
template<> ::google::internal::federated::plan::SlicesTestDataset* Arena::CreateMaybeMessage<::google::internal::federated::plan::SlicesTestDataset>(Arena*);
template<> ::google::internal::federated::plan::SlicesTestDataset_DatasetEntry_DoNotUse* Arena::CreateMaybeMessage<::google::internal::federated::plan::SlicesTestDataset_DatasetEntry_DoNotUse>(Arena*);
template<> ::google::internal::federated::plan::SumOptions* Arena::CreateMaybeMessage<::google::internal::federated::plan::SumOptions>(Arena*);
template<> ::google::internal::federated::plan::TEContextServerEligibilityIORouter* Arena::CreateMaybeMessage<::google::internal::federated::plan::TEContextServerEligibilityIORouter>(Arena*);
template<> ::google::internal::federated::plan::TFV1CheckpointAggregation* Arena::CreateMaybeMessage<::google::internal::federated::plan::TFV1CheckpointAggregation>(Arena*);
template<> ::google::internal::federated::plan::TensorflowSpec* Arena::CreateMaybeMessage<::google::internal::federated::plan::TensorflowSpec>(Arena*);
template<> ::google::internal::federated::plan::TensorflowSpec_ConstantInputsEntry_DoNotUse* Arena::CreateMaybeMessage<::google::internal::federated::plan::TensorflowSpec_ConstantInputsEntry_DoNotUse>(Arena*);
template<> ::google::internal::federated::plan::VisualizationSpec* Arena::CreateMaybeMessage<::google::internal::federated::plan::VisualizationSpec>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace google {
namespace internal {
namespace federated {
namespace plan {

enum VisualizationSpec_VisualizationType : int {
  VisualizationSpec_VisualizationType_NONE = 0,
  VisualizationSpec_VisualizationType_DEFAULT_PLOT_FOR_TASK_TYPE = 1,
  VisualizationSpec_VisualizationType_LINE_PLOT = 2,
  VisualizationSpec_VisualizationType_LINE_PLOT_WITH_PERCENTILES = 3,
  VisualizationSpec_VisualizationType_HISTOGRAM = 4,
  VisualizationSpec_VisualizationType_VisualizationSpec_VisualizationType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::min(),
  VisualizationSpec_VisualizationType_VisualizationSpec_VisualizationType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::max()
};
bool VisualizationSpec_VisualizationType_IsValid(int value);
constexpr VisualizationSpec_VisualizationType VisualizationSpec_VisualizationType_VisualizationType_MIN = VisualizationSpec_VisualizationType_NONE;
constexpr VisualizationSpec_VisualizationType VisualizationSpec_VisualizationType_VisualizationType_MAX = VisualizationSpec_VisualizationType_HISTOGRAM;
constexpr int VisualizationSpec_VisualizationType_VisualizationType_ARRAYSIZE = VisualizationSpec_VisualizationType_VisualizationType_MAX + 1;

const std::string& VisualizationSpec_VisualizationType_Name(VisualizationSpec_VisualizationType value);
template<typename T>
inline const std::string& VisualizationSpec_VisualizationType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, VisualizationSpec_VisualizationType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function VisualizationSpec_VisualizationType_Name.");
  return VisualizationSpec_VisualizationType_Name(static_cast<VisualizationSpec_VisualizationType>(enum_t_value));
}
bool VisualizationSpec_VisualizationType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, VisualizationSpec_VisualizationType* value);
enum ExampleQuerySpec_OutputVectorSpec_DataType : int {
  ExampleQuerySpec_OutputVectorSpec_DataType_UNSPECIFIED = 0,
  ExampleQuerySpec_OutputVectorSpec_DataType_INT32 = 1,
  ExampleQuerySpec_OutputVectorSpec_DataType_INT64 = 2,
  ExampleQuerySpec_OutputVectorSpec_DataType_BOOL = 3,
  ExampleQuerySpec_OutputVectorSpec_DataType_FLOAT = 4,
  ExampleQuerySpec_OutputVectorSpec_DataType_DOUBLE = 5,
  ExampleQuerySpec_OutputVectorSpec_DataType_BYTES = 6,
  ExampleQuerySpec_OutputVectorSpec_DataType_STRING = 7,
  ExampleQuerySpec_OutputVectorSpec_DataType_ExampleQuerySpec_OutputVectorSpec_DataType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::min(),
  ExampleQuerySpec_OutputVectorSpec_DataType_ExampleQuerySpec_OutputVectorSpec_DataType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::max()
};
bool ExampleQuerySpec_OutputVectorSpec_DataType_IsValid(int value);
constexpr ExampleQuerySpec_OutputVectorSpec_DataType ExampleQuerySpec_OutputVectorSpec_DataType_DataType_MIN = ExampleQuerySpec_OutputVectorSpec_DataType_UNSPECIFIED;
constexpr ExampleQuerySpec_OutputVectorSpec_DataType ExampleQuerySpec_OutputVectorSpec_DataType_DataType_MAX = ExampleQuerySpec_OutputVectorSpec_DataType_STRING;
constexpr int ExampleQuerySpec_OutputVectorSpec_DataType_DataType_ARRAYSIZE = ExampleQuerySpec_OutputVectorSpec_DataType_DataType_MAX + 1;

const std::string& ExampleQuerySpec_OutputVectorSpec_DataType_Name(ExampleQuerySpec_OutputVectorSpec_DataType value);
template<typename T>
inline const std::string& ExampleQuerySpec_OutputVectorSpec_DataType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ExampleQuerySpec_OutputVectorSpec_DataType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ExampleQuerySpec_OutputVectorSpec_DataType_Name.");
  return ExampleQuerySpec_OutputVectorSpec_DataType_Name(static_cast<ExampleQuerySpec_OutputVectorSpec_DataType>(enum_t_value));
}
bool ExampleQuerySpec_OutputVectorSpec_DataType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ExampleQuerySpec_OutputVectorSpec_DataType* value);
// ===================================================================

class CheckpointOp_SideChannelTensorsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<CheckpointOp_SideChannelTensorsEntry_DoNotUse,
    std::string, ::google::internal::federated::plan::SideChannel,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<CheckpointOp_SideChannelTensorsEntry_DoNotUse,
    std::string, ::google::internal::federated::plan::SideChannel,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  CheckpointOp_SideChannelTensorsEntry_DoNotUse();
  explicit PROTOBUF_CONSTEXPR CheckpointOp_SideChannelTensorsEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit CheckpointOp_SideChannelTensorsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const CheckpointOp_SideChannelTensorsEntry_DoNotUse& other);
  static const CheckpointOp_SideChannelTensorsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const CheckpointOp_SideChannelTensorsEntry_DoNotUse*>(&_CheckpointOp_SideChannelTensorsEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "google.internal.federated.plan.CheckpointOp.SideChannelTensorsEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};

// -------------------------------------------------------------------

class CheckpointOp final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.CheckpointOp) */ {
 public:
  inline CheckpointOp() : CheckpointOp(nullptr) {}
  ~CheckpointOp() override;
  explicit PROTOBUF_CONSTEXPR CheckpointOp(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CheckpointOp(const CheckpointOp& from);
  CheckpointOp(CheckpointOp&& from) noexcept
    : CheckpointOp() {
    *this = ::std::move(from);
  }

  inline CheckpointOp& operator=(const CheckpointOp& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline CheckpointOp& operator=(CheckpointOp&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const CheckpointOp& default_instance() {
    return *internal_default_instance();
  }
  static inline const CheckpointOp* internal_default_instance() {
    return reinterpret_cast<const CheckpointOp*>(
               &_CheckpointOp_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(CheckpointOp& a, CheckpointOp& b) {
    a.Swap(&b);
  }
  inline void Swap(CheckpointOp* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CheckpointOp* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CheckpointOp* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CheckpointOp>(arena);
  }
  CheckpointOp* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const CheckpointOp& from);
  void MergeFrom(const CheckpointOp& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(CheckpointOp* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.CheckpointOp";
  }
  protected:
  explicit CheckpointOp(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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


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

  enum : int {
    kSideChannelTensorsFieldNumber = 6,
    kBeforeRestoreOpFieldNumber = 2,
    kAfterRestoreOpFieldNumber = 3,
    kBeforeSaveOpFieldNumber = 4,
    kAfterSaveOpFieldNumber = 5,
    kSessionTokenTensorNameFieldNumber = 7,
    kSaverDefFieldNumber = 1,
  };
  // map<string, .google.internal.federated.plan.SideChannel> side_channel_tensors = 6;
  int side_channel_tensors_size() const;
  private:
  int _internal_side_channel_tensors_size() const;
  public:
  void clear_side_channel_tensors();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::SideChannel >&
      _internal_side_channel_tensors() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::SideChannel >*
      _internal_mutable_side_channel_tensors();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::SideChannel >&
      side_channel_tensors() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::SideChannel >*
      mutable_side_channel_tensors();

  // string before_restore_op = 2;
  void clear_before_restore_op();
  const std::string& before_restore_op() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_before_restore_op(ArgT0&& arg0, ArgT... args);
  std::string* mutable_before_restore_op();
  PROTOBUF_NODISCARD std::string* release_before_restore_op();
  void set_allocated_before_restore_op(std::string* before_restore_op);
  private:
  const std::string& _internal_before_restore_op() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_before_restore_op(const std::string& value);
  std::string* _internal_mutable_before_restore_op();
  public:

  // string after_restore_op = 3;
  void clear_after_restore_op();
  const std::string& after_restore_op() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_after_restore_op(ArgT0&& arg0, ArgT... args);
  std::string* mutable_after_restore_op();
  PROTOBUF_NODISCARD std::string* release_after_restore_op();
  void set_allocated_after_restore_op(std::string* after_restore_op);
  private:
  const std::string& _internal_after_restore_op() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_after_restore_op(const std::string& value);
  std::string* _internal_mutable_after_restore_op();
  public:

  // string before_save_op = 4;
  void clear_before_save_op();
  const std::string& before_save_op() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_before_save_op(ArgT0&& arg0, ArgT... args);
  std::string* mutable_before_save_op();
  PROTOBUF_NODISCARD std::string* release_before_save_op();
  void set_allocated_before_save_op(std::string* before_save_op);
  private:
  const std::string& _internal_before_save_op() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_before_save_op(const std::string& value);
  std::string* _internal_mutable_before_save_op();
  public:

  // string after_save_op = 5;
  void clear_after_save_op();
  const std::string& after_save_op() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_after_save_op(ArgT0&& arg0, ArgT... args);
  std::string* mutable_after_save_op();
  PROTOBUF_NODISCARD std::string* release_after_save_op();
  void set_allocated_after_save_op(std::string* after_save_op);
  private:
  const std::string& _internal_after_save_op() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_after_save_op(const std::string& value);
  std::string* _internal_mutable_after_save_op();
  public:

  // string session_token_tensor_name = 7;
  void clear_session_token_tensor_name();
  const std::string& session_token_tensor_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_session_token_tensor_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_session_token_tensor_name();
  PROTOBUF_NODISCARD std::string* release_session_token_tensor_name();
  void set_allocated_session_token_tensor_name(std::string* session_token_tensor_name);
  private:
  const std::string& _internal_session_token_tensor_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_token_tensor_name(const std::string& value);
  std::string* _internal_mutable_session_token_tensor_name();
  public:

  // .tensorflow.SaverDef saver_def = 1;
  bool has_saver_def() const;
  private:
  bool _internal_has_saver_def() const;
  public:
  void clear_saver_def();
  const ::tensorflow::SaverDef& saver_def() const;
  PROTOBUF_NODISCARD ::tensorflow::SaverDef* release_saver_def();
  ::tensorflow::SaverDef* mutable_saver_def();
  void set_allocated_saver_def(::tensorflow::SaverDef* saver_def);
  private:
  const ::tensorflow::SaverDef& _internal_saver_def() const;
  ::tensorflow::SaverDef* _internal_mutable_saver_def();
  public:
  void unsafe_arena_set_allocated_saver_def(
      ::tensorflow::SaverDef* saver_def);
  ::tensorflow::SaverDef* unsafe_arena_release_saver_def();

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.CheckpointOp)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::MapFieldLite<
        CheckpointOp_SideChannelTensorsEntry_DoNotUse,
        std::string, ::google::internal::federated::plan::SideChannel,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> side_channel_tensors_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr before_restore_op_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr after_restore_op_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr before_save_op_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr after_save_op_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr session_token_tensor_name_;
    ::tensorflow::SaverDef* saver_def_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class SideChannel_SecureAggregand_Dimension final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.SideChannel.SecureAggregand.Dimension) */ {
 public:
  inline SideChannel_SecureAggregand_Dimension() : SideChannel_SecureAggregand_Dimension(nullptr) {}
  ~SideChannel_SecureAggregand_Dimension() override;
  explicit PROTOBUF_CONSTEXPR SideChannel_SecureAggregand_Dimension(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SideChannel_SecureAggregand_Dimension(const SideChannel_SecureAggregand_Dimension& from);
  SideChannel_SecureAggregand_Dimension(SideChannel_SecureAggregand_Dimension&& from) noexcept
    : SideChannel_SecureAggregand_Dimension() {
    *this = ::std::move(from);
  }

  inline SideChannel_SecureAggregand_Dimension& operator=(const SideChannel_SecureAggregand_Dimension& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline SideChannel_SecureAggregand_Dimension& operator=(SideChannel_SecureAggregand_Dimension&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const SideChannel_SecureAggregand_Dimension& default_instance() {
    return *internal_default_instance();
  }
  static inline const SideChannel_SecureAggregand_Dimension* internal_default_instance() {
    return reinterpret_cast<const SideChannel_SecureAggregand_Dimension*>(
               &_SideChannel_SecureAggregand_Dimension_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(SideChannel_SecureAggregand_Dimension& a, SideChannel_SecureAggregand_Dimension& b) {
    a.Swap(&b);
  }
  inline void Swap(SideChannel_SecureAggregand_Dimension* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SideChannel_SecureAggregand_Dimension* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SideChannel_SecureAggregand_Dimension* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SideChannel_SecureAggregand_Dimension>(arena);
  }
  SideChannel_SecureAggregand_Dimension* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SideChannel_SecureAggregand_Dimension& from);
  void MergeFrom(const SideChannel_SecureAggregand_Dimension& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SideChannel_SecureAggregand_Dimension* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.SideChannel.SecureAggregand.Dimension";
  }
  protected:
  explicit SideChannel_SecureAggregand_Dimension(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kSizeFieldNumber = 1,
  };
  // int64 size = 1;
  void clear_size();
  ::int64_t size() const;
  void set_size(::int64_t value);
  private:
  ::int64_t _internal_size() const;
  void _internal_set_size(::int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.SideChannel.SecureAggregand.Dimension)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::int64_t size_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class SideChannel_SecureAggregand_FixedModulus final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.SideChannel.SecureAggregand.FixedModulus) */ {
 public:
  inline SideChannel_SecureAggregand_FixedModulus() : SideChannel_SecureAggregand_FixedModulus(nullptr) {}
  ~SideChannel_SecureAggregand_FixedModulus() override;
  explicit PROTOBUF_CONSTEXPR SideChannel_SecureAggregand_FixedModulus(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SideChannel_SecureAggregand_FixedModulus(const SideChannel_SecureAggregand_FixedModulus& from);
  SideChannel_SecureAggregand_FixedModulus(SideChannel_SecureAggregand_FixedModulus&& from) noexcept
    : SideChannel_SecureAggregand_FixedModulus() {
    *this = ::std::move(from);
  }

  inline SideChannel_SecureAggregand_FixedModulus& operator=(const SideChannel_SecureAggregand_FixedModulus& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline SideChannel_SecureAggregand_FixedModulus& operator=(SideChannel_SecureAggregand_FixedModulus&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const SideChannel_SecureAggregand_FixedModulus& default_instance() {
    return *internal_default_instance();
  }
  static inline const SideChannel_SecureAggregand_FixedModulus* internal_default_instance() {
    return reinterpret_cast<const SideChannel_SecureAggregand_FixedModulus*>(
               &_SideChannel_SecureAggregand_FixedModulus_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(SideChannel_SecureAggregand_FixedModulus& a, SideChannel_SecureAggregand_FixedModulus& b) {
    a.Swap(&b);
  }
  inline void Swap(SideChannel_SecureAggregand_FixedModulus* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SideChannel_SecureAggregand_FixedModulus* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SideChannel_SecureAggregand_FixedModulus* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SideChannel_SecureAggregand_FixedModulus>(arena);
  }
  SideChannel_SecureAggregand_FixedModulus* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SideChannel_SecureAggregand_FixedModulus& from);
  void MergeFrom(const SideChannel_SecureAggregand_FixedModulus& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SideChannel_SecureAggregand_FixedModulus* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.SideChannel.SecureAggregand.FixedModulus";
  }
  protected:
  explicit SideChannel_SecureAggregand_FixedModulus(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kModulusFieldNumber = 1,
  };
  // uint64 modulus = 1;
  void clear_modulus();
  ::uint64_t modulus() const;
  void set_modulus(::uint64_t value);
  private:
  ::uint64_t _internal_modulus() const;
  void _internal_set_modulus(::uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.SideChannel.SecureAggregand.FixedModulus)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::uint64_t modulus_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class SideChannel_SecureAggregand_ModulusTimesShardSize final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.SideChannel.SecureAggregand.ModulusTimesShardSize) */ {
 public:
  inline SideChannel_SecureAggregand_ModulusTimesShardSize() : SideChannel_SecureAggregand_ModulusTimesShardSize(nullptr) {}
  ~SideChannel_SecureAggregand_ModulusTimesShardSize() override;
  explicit PROTOBUF_CONSTEXPR SideChannel_SecureAggregand_ModulusTimesShardSize(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SideChannel_SecureAggregand_ModulusTimesShardSize(const SideChannel_SecureAggregand_ModulusTimesShardSize& from);
  SideChannel_SecureAggregand_ModulusTimesShardSize(SideChannel_SecureAggregand_ModulusTimesShardSize&& from) noexcept
    : SideChannel_SecureAggregand_ModulusTimesShardSize() {
    *this = ::std::move(from);
  }

  inline SideChannel_SecureAggregand_ModulusTimesShardSize& operator=(const SideChannel_SecureAggregand_ModulusTimesShardSize& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline SideChannel_SecureAggregand_ModulusTimesShardSize& operator=(SideChannel_SecureAggregand_ModulusTimesShardSize&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const SideChannel_SecureAggregand_ModulusTimesShardSize& default_instance() {
    return *internal_default_instance();
  }
  static inline const SideChannel_SecureAggregand_ModulusTimesShardSize* internal_default_instance() {
    return reinterpret_cast<const SideChannel_SecureAggregand_ModulusTimesShardSize*>(
               &_SideChannel_SecureAggregand_ModulusTimesShardSize_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(SideChannel_SecureAggregand_ModulusTimesShardSize& a, SideChannel_SecureAggregand_ModulusTimesShardSize& b) {
    a.Swap(&b);
  }
  inline void Swap(SideChannel_SecureAggregand_ModulusTimesShardSize* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SideChannel_SecureAggregand_ModulusTimesShardSize* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SideChannel_SecureAggregand_ModulusTimesShardSize* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SideChannel_SecureAggregand_ModulusTimesShardSize>(arena);
  }
  SideChannel_SecureAggregand_ModulusTimesShardSize* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SideChannel_SecureAggregand_ModulusTimesShardSize& from);
  void MergeFrom(const SideChannel_SecureAggregand_ModulusTimesShardSize& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SideChannel_SecureAggregand_ModulusTimesShardSize* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.SideChannel.SecureAggregand.ModulusTimesShardSize";
  }
  protected:
  explicit SideChannel_SecureAggregand_ModulusTimesShardSize(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kBaseModulusFieldNumber = 1,
  };
  // uint64 base_modulus = 1;
  void clear_base_modulus();
  ::uint64_t base_modulus() const;
  void set_base_modulus(::uint64_t value);
  private:
  ::uint64_t _internal_base_modulus() const;
  void _internal_set_base_modulus(::uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.SideChannel.SecureAggregand.ModulusTimesShardSize)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::uint64_t base_modulus_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class SideChannel_SecureAggregand final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.SideChannel.SecureAggregand) */ {
 public:
  inline SideChannel_SecureAggregand() : SideChannel_SecureAggregand(nullptr) {}
  ~SideChannel_SecureAggregand() override;
  explicit PROTOBUF_CONSTEXPR SideChannel_SecureAggregand(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SideChannel_SecureAggregand(const SideChannel_SecureAggregand& from);
  SideChannel_SecureAggregand(SideChannel_SecureAggregand&& from) noexcept
    : SideChannel_SecureAggregand() {
    *this = ::std::move(from);
  }

  inline SideChannel_SecureAggregand& operator=(const SideChannel_SecureAggregand& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline SideChannel_SecureAggregand& operator=(SideChannel_SecureAggregand&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const SideChannel_SecureAggregand& default_instance() {
    return *internal_default_instance();
  }
  enum ModulusSchemeCase {
    kQuantizedInputBitwidth = 2,
    kFixedModulus = 5,
    kModulusTimesShardSize = 6,
    MODULUS_SCHEME_NOT_SET = 0,
  };

  static inline const SideChannel_SecureAggregand* internal_default_instance() {
    return reinterpret_cast<const SideChannel_SecureAggregand*>(
               &_SideChannel_SecureAggregand_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(SideChannel_SecureAggregand& a, SideChannel_SecureAggregand& b) {
    a.Swap(&b);
  }
  inline void Swap(SideChannel_SecureAggregand* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SideChannel_SecureAggregand* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SideChannel_SecureAggregand* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SideChannel_SecureAggregand>(arena);
  }
  SideChannel_SecureAggregand* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SideChannel_SecureAggregand& from);
  void MergeFrom(const SideChannel_SecureAggregand& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SideChannel_SecureAggregand* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.SideChannel.SecureAggregand";
  }
  protected:
  explicit SideChannel_SecureAggregand(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

  typedef SideChannel_SecureAggregand_Dimension Dimension;
  typedef SideChannel_SecureAggregand_FixedModulus FixedModulus;
  typedef SideChannel_SecureAggregand_ModulusTimesShardSize ModulusTimesShardSize;

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

  enum : int {
    kDimensionFieldNumber = 3,
    kDtypeFieldNumber = 4,
    kQuantizedInputBitwidthFieldNumber = 2,
    kFixedModulusFieldNumber = 5,
    kModulusTimesShardSizeFieldNumber = 6,
  };
  // repeated .google.internal.federated.plan.SideChannel.SecureAggregand.Dimension dimension = 3;
  int dimension_size() const;
  private:
  int _internal_dimension_size() const;
  public:
  void clear_dimension();
  ::google::internal::federated::plan::SideChannel_SecureAggregand_Dimension* mutable_dimension(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::SideChannel_SecureAggregand_Dimension >*
      mutable_dimension();
  private:
  const ::google::internal::federated::plan::SideChannel_SecureAggregand_Dimension& _internal_dimension(int index) const;
  ::google::internal::federated::plan::SideChannel_SecureAggregand_Dimension* _internal_add_dimension();
  public:
  const ::google::internal::federated::plan::SideChannel_SecureAggregand_Dimension& dimension(int index) const;
  ::google::internal::federated::plan::SideChannel_SecureAggregand_Dimension* add_dimension();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::SideChannel_SecureAggregand_Dimension >&
      dimension() const;

  // .tensorflow.DataType dtype = 4;
  void clear_dtype();
  ::tensorflow::DataType dtype() const;
  void set_dtype(::tensorflow::DataType value);
  private:
  ::tensorflow::DataType _internal_dtype() const;
  void _internal_set_dtype(::tensorflow::DataType value);
  public:

  // int32 quantized_input_bitwidth = 2 [deprecated = true];
  PROTOBUF_DEPRECATED bool has_quantized_input_bitwidth() const;
  private:
  bool _internal_has_quantized_input_bitwidth() const;
  public:
  PROTOBUF_DEPRECATED void clear_quantized_input_bitwidth();
  PROTOBUF_DEPRECATED ::int32_t quantized_input_bitwidth() const;
  PROTOBUF_DEPRECATED void set_quantized_input_bitwidth(::int32_t value);
  private:
  ::int32_t _internal_quantized_input_bitwidth() const;
  void _internal_set_quantized_input_bitwidth(::int32_t value);
  public:

  // .google.internal.federated.plan.SideChannel.SecureAggregand.FixedModulus fixed_modulus = 5;
  bool has_fixed_modulus() const;
  private:
  bool _internal_has_fixed_modulus() const;
  public:
  void clear_fixed_modulus();
  const ::google::internal::federated::plan::SideChannel_SecureAggregand_FixedModulus& fixed_modulus() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::SideChannel_SecureAggregand_FixedModulus* release_fixed_modulus();
  ::google::internal::federated::plan::SideChannel_SecureAggregand_FixedModulus* mutable_fixed_modulus();
  void set_allocated_fixed_modulus(::google::internal::federated::plan::SideChannel_SecureAggregand_FixedModulus* fixed_modulus);
  private:
  const ::google::internal::federated::plan::SideChannel_SecureAggregand_FixedModulus& _internal_fixed_modulus() const;
  ::google::internal::federated::plan::SideChannel_SecureAggregand_FixedModulus* _internal_mutable_fixed_modulus();
  public:
  void unsafe_arena_set_allocated_fixed_modulus(
      ::google::internal::federated::plan::SideChannel_SecureAggregand_FixedModulus* fixed_modulus);
  ::google::internal::federated::plan::SideChannel_SecureAggregand_FixedModulus* unsafe_arena_release_fixed_modulus();

  // .google.internal.federated.plan.SideChannel.SecureAggregand.ModulusTimesShardSize modulus_times_shard_size = 6;
  bool has_modulus_times_shard_size() const;
  private:
  bool _internal_has_modulus_times_shard_size() const;
  public:
  void clear_modulus_times_shard_size();
  const ::google::internal::federated::plan::SideChannel_SecureAggregand_ModulusTimesShardSize& modulus_times_shard_size() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::SideChannel_SecureAggregand_ModulusTimesShardSize* release_modulus_times_shard_size();
  ::google::internal::federated::plan::SideChannel_SecureAggregand_ModulusTimesShardSize* mutable_modulus_times_shard_size();
  void set_allocated_modulus_times_shard_size(::google::internal::federated::plan::SideChannel_SecureAggregand_ModulusTimesShardSize* modulus_times_shard_size);
  private:
  const ::google::internal::federated::plan::SideChannel_SecureAggregand_ModulusTimesShardSize& _internal_modulus_times_shard_size() const;
  ::google::internal::federated::plan::SideChannel_SecureAggregand_ModulusTimesShardSize* _internal_mutable_modulus_times_shard_size();
  public:
  void unsafe_arena_set_allocated_modulus_times_shard_size(
      ::google::internal::federated::plan::SideChannel_SecureAggregand_ModulusTimesShardSize* modulus_times_shard_size);
  ::google::internal::federated::plan::SideChannel_SecureAggregand_ModulusTimesShardSize* unsafe_arena_release_modulus_times_shard_size();

  void clear_modulus_scheme();
  ModulusSchemeCase modulus_scheme_case() const;
  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.SideChannel.SecureAggregand)
 private:
  class _Internal;
  void set_has_quantized_input_bitwidth();
  void set_has_fixed_modulus();
  void set_has_modulus_times_shard_size();

  inline bool has_modulus_scheme() const;
  inline void clear_has_modulus_scheme();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::SideChannel_SecureAggregand_Dimension > dimension_;
    int dtype_;
    union ModulusSchemeUnion {
      constexpr ModulusSchemeUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::int32_t quantized_input_bitwidth_;
      ::google::internal::federated::plan::SideChannel_SecureAggregand_FixedModulus* fixed_modulus_;
      ::google::internal::federated::plan::SideChannel_SecureAggregand_ModulusTimesShardSize* modulus_times_shard_size_;
    } modulus_scheme_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class SideChannel final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.SideChannel) */ {
 public:
  inline SideChannel() : SideChannel(nullptr) {}
  ~SideChannel() override;
  explicit PROTOBUF_CONSTEXPR SideChannel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SideChannel(const SideChannel& from);
  SideChannel(SideChannel&& from) noexcept
    : SideChannel() {
    *this = ::std::move(from);
  }

  inline SideChannel& operator=(const SideChannel& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline SideChannel& operator=(SideChannel&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const SideChannel& default_instance() {
    return *internal_default_instance();
  }
  enum TypeCase {
    kSecureAggregand = 1,
    TYPE_NOT_SET = 0,
  };

  static inline const SideChannel* internal_default_instance() {
    return reinterpret_cast<const SideChannel*>(
               &_SideChannel_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(SideChannel& a, SideChannel& b) {
    a.Swap(&b);
  }
  inline void Swap(SideChannel* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SideChannel* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SideChannel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SideChannel>(arena);
  }
  SideChannel* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SideChannel& from);
  void MergeFrom(const SideChannel& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SideChannel* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.SideChannel";
  }
  protected:
  explicit SideChannel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

  typedef SideChannel_SecureAggregand SecureAggregand;

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

  enum : int {
    kRestoreNameFieldNumber = 2,
    kSecureAggregandFieldNumber = 1,
  };
  // string restore_name = 2;
  void clear_restore_name();
  const std::string& restore_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_restore_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_restore_name();
  PROTOBUF_NODISCARD std::string* release_restore_name();
  void set_allocated_restore_name(std::string* restore_name);
  private:
  const std::string& _internal_restore_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_restore_name(const std::string& value);
  std::string* _internal_mutable_restore_name();
  public:

  // .google.internal.federated.plan.SideChannel.SecureAggregand secure_aggregand = 1;
  bool has_secure_aggregand() const;
  private:
  bool _internal_has_secure_aggregand() const;
  public:
  void clear_secure_aggregand();
  const ::google::internal::federated::plan::SideChannel_SecureAggregand& secure_aggregand() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::SideChannel_SecureAggregand* release_secure_aggregand();
  ::google::internal::federated::plan::SideChannel_SecureAggregand* mutable_secure_aggregand();
  void set_allocated_secure_aggregand(::google::internal::federated::plan::SideChannel_SecureAggregand* secure_aggregand);
  private:
  const ::google::internal::federated::plan::SideChannel_SecureAggregand& _internal_secure_aggregand() const;
  ::google::internal::federated::plan::SideChannel_SecureAggregand* _internal_mutable_secure_aggregand();
  public:
  void unsafe_arena_set_allocated_secure_aggregand(
      ::google::internal::federated::plan::SideChannel_SecureAggregand* secure_aggregand);
  ::google::internal::federated::plan::SideChannel_SecureAggregand* unsafe_arena_release_secure_aggregand();

  void clear_type();
  TypeCase type_case() const;
  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.SideChannel)
 private:
  class _Internal;
  void set_has_secure_aggregand();

  inline bool has_type() const;
  inline void clear_has_type();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr restore_name_;
    union TypeUnion {
      constexpr TypeUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::google::internal::federated::plan::SideChannel_SecureAggregand* secure_aggregand_;
    } type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class Metric final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.Metric) */ {
 public:
  inline Metric() : Metric(nullptr) {}
  ~Metric() override;
  explicit PROTOBUF_CONSTEXPR Metric(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Metric(const Metric& from);
  Metric(Metric&& from) noexcept
    : Metric() {
    *this = ::std::move(from);
  }

  inline Metric& operator=(const Metric& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline Metric& operator=(Metric&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const Metric& default_instance() {
    return *internal_default_instance();
  }
  static inline const Metric* internal_default_instance() {
    return reinterpret_cast<const Metric*>(
               &_Metric_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(Metric& a, Metric& b) {
    a.Swap(&b);
  }
  inline void Swap(Metric* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Metric* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Metric* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Metric>(arena);
  }
  Metric* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const Metric& from);
  void MergeFrom(const Metric& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Metric* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.Metric";
  }
  protected:
  explicit Metric(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kVariableNameFieldNumber = 1,
    kStatNameFieldNumber = 2,
    kWeightNameFieldNumber = 3,
  };
  // string variable_name = 1;
  void clear_variable_name();
  const std::string& variable_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_variable_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_variable_name();
  PROTOBUF_NODISCARD std::string* release_variable_name();
  void set_allocated_variable_name(std::string* variable_name);
  private:
  const std::string& _internal_variable_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_variable_name(const std::string& value);
  std::string* _internal_mutable_variable_name();
  public:

  // string stat_name = 2;
  void clear_stat_name();
  const std::string& stat_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_stat_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_stat_name();
  PROTOBUF_NODISCARD std::string* release_stat_name();
  void set_allocated_stat_name(std::string* stat_name);
  private:
  const std::string& _internal_stat_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_stat_name(const std::string& value);
  std::string* _internal_mutable_stat_name();
  public:

  // string weight_name = 3;
  void clear_weight_name();
  const std::string& weight_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_weight_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_weight_name();
  PROTOBUF_NODISCARD std::string* release_weight_name();
  void set_allocated_weight_name(std::string* weight_name);
  private:
  const std::string& _internal_weight_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_weight_name(const std::string& value);
  std::string* _internal_mutable_weight_name();
  public:

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.Metric)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr variable_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr stat_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr weight_name_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class OutputMetric final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.OutputMetric) */ {
 public:
  inline OutputMetric() : OutputMetric(nullptr) {}
  ~OutputMetric() override;
  explicit PROTOBUF_CONSTEXPR OutputMetric(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  OutputMetric(const OutputMetric& from);
  OutputMetric(OutputMetric&& from) noexcept
    : OutputMetric() {
    *this = ::std::move(from);
  }

  inline OutputMetric& operator=(const OutputMetric& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline OutputMetric& operator=(OutputMetric&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const OutputMetric& default_instance() {
    return *internal_default_instance();
  }
  enum ValueSourceCase {
    kSum = 2,
    kAverage = 3,
    kNone = 4,
    kOnlySample = 5,
    VALUE_SOURCE_NOT_SET = 0,
  };

  enum VisualizationInfoCase {
    kAutoPlot = 6,
    kPlotSpec = 7,
    VISUALIZATION_INFO_NOT_SET = 0,
  };

  static inline const OutputMetric* internal_default_instance() {
    return reinterpret_cast<const OutputMetric*>(
               &_OutputMetric_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(OutputMetric& a, OutputMetric& b) {
    a.Swap(&b);
  }
  inline void Swap(OutputMetric* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(OutputMetric* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  OutputMetric* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<OutputMetric>(arena);
  }
  OutputMetric* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const OutputMetric& from);
  void MergeFrom(const OutputMetric& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(OutputMetric* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.OutputMetric";
  }
  protected:
  explicit OutputMetric(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kNameFieldNumber = 1,
    kSumFieldNumber = 2,
    kAverageFieldNumber = 3,
    kNoneFieldNumber = 4,
    kOnlySampleFieldNumber = 5,
    kAutoPlotFieldNumber = 6,
    kPlotSpecFieldNumber = 7,
  };
  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // .google.internal.federated.plan.SumOptions sum = 2;
  bool has_sum() const;
  private:
  bool _internal_has_sum() const;
  public:
  void clear_sum();
  const ::google::internal::federated::plan::SumOptions& sum() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::SumOptions* release_sum();
  ::google::internal::federated::plan::SumOptions* mutable_sum();
  void set_allocated_sum(::google::internal::federated::plan::SumOptions* sum);
  private:
  const ::google::internal::federated::plan::SumOptions& _internal_sum() const;
  ::google::internal::federated::plan::SumOptions* _internal_mutable_sum();
  public:
  void unsafe_arena_set_allocated_sum(
      ::google::internal::federated::plan::SumOptions* sum);
  ::google::internal::federated::plan::SumOptions* unsafe_arena_release_sum();

  // .google.internal.federated.plan.AverageOptions average = 3;
  bool has_average() const;
  private:
  bool _internal_has_average() const;
  public:
  void clear_average();
  const ::google::internal::federated::plan::AverageOptions& average() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::AverageOptions* release_average();
  ::google::internal::federated::plan::AverageOptions* mutable_average();
  void set_allocated_average(::google::internal::federated::plan::AverageOptions* average);
  private:
  const ::google::internal::federated::plan::AverageOptions& _internal_average() const;
  ::google::internal::federated::plan::AverageOptions* _internal_mutable_average();
  public:
  void unsafe_arena_set_allocated_average(
      ::google::internal::federated::plan::AverageOptions* average);
  ::google::internal::federated::plan::AverageOptions* unsafe_arena_release_average();

  // .google.internal.federated.plan.NoneOptions none = 4;
  bool has_none() const;
  private:
  bool _internal_has_none() const;
  public:
  void clear_none();
  const ::google::internal::federated::plan::NoneOptions& none() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::NoneOptions* release_none();
  ::google::internal::federated::plan::NoneOptions* mutable_none();
  void set_allocated_none(::google::internal::federated::plan::NoneOptions* none);
  private:
  const ::google::internal::federated::plan::NoneOptions& _internal_none() const;
  ::google::internal::federated::plan::NoneOptions* _internal_mutable_none();
  public:
  void unsafe_arena_set_allocated_none(
      ::google::internal::federated::plan::NoneOptions* none);
  ::google::internal::federated::plan::NoneOptions* unsafe_arena_release_none();

  // .google.internal.federated.plan.OnlySampleOptions only_sample = 5;
  bool has_only_sample() const;
  private:
  bool _internal_has_only_sample() const;
  public:
  void clear_only_sample();
  const ::google::internal::federated::plan::OnlySampleOptions& only_sample() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::OnlySampleOptions* release_only_sample();
  ::google::internal::federated::plan::OnlySampleOptions* mutable_only_sample();
  void set_allocated_only_sample(::google::internal::federated::plan::OnlySampleOptions* only_sample);
  private:
  const ::google::internal::federated::plan::OnlySampleOptions& _internal_only_sample() const;
  ::google::internal::federated::plan::OnlySampleOptions* _internal_mutable_only_sample();
  public:
  void unsafe_arena_set_allocated_only_sample(
      ::google::internal::federated::plan::OnlySampleOptions* only_sample);
  ::google::internal::federated::plan::OnlySampleOptions* unsafe_arena_release_only_sample();

  // bool auto_plot = 6 [deprecated = true];
  PROTOBUF_DEPRECATED bool has_auto_plot() const;
  private:
  bool _internal_has_auto_plot() const;
  public:
  PROTOBUF_DEPRECATED void clear_auto_plot();
  PROTOBUF_DEPRECATED bool auto_plot() const;
  PROTOBUF_DEPRECATED void set_auto_plot(bool value);
  private:
  bool _internal_auto_plot() const;
  void _internal_set_auto_plot(bool value);
  public:

  // .google.internal.federated.plan.VisualizationSpec plot_spec = 7;
  bool has_plot_spec() const;
  private:
  bool _internal_has_plot_spec() const;
  public:
  void clear_plot_spec();
  const ::google::internal::federated::plan::VisualizationSpec& plot_spec() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::VisualizationSpec* release_plot_spec();
  ::google::internal::federated::plan::VisualizationSpec* mutable_plot_spec();
  void set_allocated_plot_spec(::google::internal::federated::plan::VisualizationSpec* plot_spec);
  private:
  const ::google::internal::federated::plan::VisualizationSpec& _internal_plot_spec() const;
  ::google::internal::federated::plan::VisualizationSpec* _internal_mutable_plot_spec();
  public:
  void unsafe_arena_set_allocated_plot_spec(
      ::google::internal::federated::plan::VisualizationSpec* plot_spec);
  ::google::internal::federated::plan::VisualizationSpec* unsafe_arena_release_plot_spec();

  void clear_value_source();
  ValueSourceCase value_source_case() const;
  void clear_visualization_info();
  VisualizationInfoCase visualization_info_case() const;
  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.OutputMetric)
 private:
  class _Internal;
  void set_has_sum();
  void set_has_average();
  void set_has_none();
  void set_has_only_sample();
  void set_has_auto_plot();
  void set_has_plot_spec();

  inline bool has_value_source() const;
  inline void clear_has_value_source();

  inline bool has_visualization_info() const;
  inline void clear_has_visualization_info();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    union ValueSourceUnion {
      constexpr ValueSourceUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::google::internal::federated::plan::SumOptions* sum_;
      ::google::internal::federated::plan::AverageOptions* average_;
      ::google::internal::federated::plan::NoneOptions* none_;
      ::google::internal::federated::plan::OnlySampleOptions* only_sample_;
    } value_source_;
    union VisualizationInfoUnion {
      constexpr VisualizationInfoUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      bool auto_plot_;
      ::google::internal::federated::plan::VisualizationSpec* plot_spec_;
    } visualization_info_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[2];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class VisualizationSpec final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.VisualizationSpec) */ {
 public:
  inline VisualizationSpec() : VisualizationSpec(nullptr) {}
  ~VisualizationSpec() override;
  explicit PROTOBUF_CONSTEXPR VisualizationSpec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  VisualizationSpec(const VisualizationSpec& from);
  VisualizationSpec(VisualizationSpec&& from) noexcept
    : VisualizationSpec() {
    *this = ::std::move(from);
  }

  inline VisualizationSpec& operator=(const VisualizationSpec& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline VisualizationSpec& operator=(VisualizationSpec&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const VisualizationSpec& default_instance() {
    return *internal_default_instance();
  }
  static inline const VisualizationSpec* internal_default_instance() {
    return reinterpret_cast<const VisualizationSpec*>(
               &_VisualizationSpec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(VisualizationSpec& a, VisualizationSpec& b) {
    a.Swap(&b);
  }
  inline void Swap(VisualizationSpec* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(VisualizationSpec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  VisualizationSpec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<VisualizationSpec>(arena);
  }
  VisualizationSpec* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const VisualizationSpec& from);
  void MergeFrom(const VisualizationSpec& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(VisualizationSpec* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.VisualizationSpec";
  }
  protected:
  explicit VisualizationSpec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

  typedef VisualizationSpec_VisualizationType VisualizationType;
  static constexpr VisualizationType NONE =
    VisualizationSpec_VisualizationType_NONE;
  static constexpr VisualizationType DEFAULT_PLOT_FOR_TASK_TYPE =
    VisualizationSpec_VisualizationType_DEFAULT_PLOT_FOR_TASK_TYPE;
  static constexpr VisualizationType LINE_PLOT =
    VisualizationSpec_VisualizationType_LINE_PLOT;
  static constexpr VisualizationType LINE_PLOT_WITH_PERCENTILES =
    VisualizationSpec_VisualizationType_LINE_PLOT_WITH_PERCENTILES;
  static constexpr VisualizationType HISTOGRAM =
    VisualizationSpec_VisualizationType_HISTOGRAM;
  static inline bool VisualizationType_IsValid(int value) {
    return VisualizationSpec_VisualizationType_IsValid(value);
  }
  static constexpr VisualizationType VisualizationType_MIN =
    VisualizationSpec_VisualizationType_VisualizationType_MIN;
  static constexpr VisualizationType VisualizationType_MAX =
    VisualizationSpec_VisualizationType_VisualizationType_MAX;
  static constexpr int VisualizationType_ARRAYSIZE =
    VisualizationSpec_VisualizationType_VisualizationType_ARRAYSIZE;
  template<typename T>
  static inline const std::string& VisualizationType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, VisualizationType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function VisualizationType_Name.");
    return VisualizationSpec_VisualizationType_Name(enum_t_value);
  }
  static inline bool VisualizationType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      VisualizationType* value) {
    return VisualizationSpec_VisualizationType_Parse(name, value);
  }

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

  enum : int {
    kXAxisFieldNumber = 2,
    kPlotTypeFieldNumber = 1,
    kPlotOnPopulationDashboardFieldNumber = 3,
  };
  // string x_axis = 2;
  void clear_x_axis();
  const std::string& x_axis() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_x_axis(ArgT0&& arg0, ArgT... args);
  std::string* mutable_x_axis();
  PROTOBUF_NODISCARD std::string* release_x_axis();
  void set_allocated_x_axis(std::string* x_axis);
  private:
  const std::string& _internal_x_axis() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_x_axis(const std::string& value);
  std::string* _internal_mutable_x_axis();
  public:

  // .google.internal.federated.plan.VisualizationSpec.VisualizationType plot_type = 1;
  void clear_plot_type();
  ::google::internal::federated::plan::VisualizationSpec_VisualizationType plot_type() const;
  void set_plot_type(::google::internal::federated::plan::VisualizationSpec_VisualizationType value);
  private:
  ::google::internal::federated::plan::VisualizationSpec_VisualizationType _internal_plot_type() const;
  void _internal_set_plot_type(::google::internal::federated::plan::VisualizationSpec_VisualizationType value);
  public:

  // bool plot_on_population_dashboard = 3;
  void clear_plot_on_population_dashboard();
  bool plot_on_population_dashboard() const;
  void set_plot_on_population_dashboard(bool value);
  private:
  bool _internal_plot_on_population_dashboard() const;
  void _internal_set_plot_on_population_dashboard(bool value);
  public:

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.VisualizationSpec)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr x_axis_;
    int plot_type_;
    bool plot_on_population_dashboard_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class SumOptions final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.SumOptions) */ {
 public:
  inline SumOptions() : SumOptions(nullptr) {}
  ~SumOptions() override;
  explicit PROTOBUF_CONSTEXPR SumOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SumOptions(const SumOptions& from);
  SumOptions(SumOptions&& from) noexcept
    : SumOptions() {
    *this = ::std::move(from);
  }

  inline SumOptions& operator=(const SumOptions& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline SumOptions& operator=(SumOptions&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const SumOptions& default_instance() {
    return *internal_default_instance();
  }
  static inline const SumOptions* internal_default_instance() {
    return reinterpret_cast<const SumOptions*>(
               &_SumOptions_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(SumOptions& a, SumOptions& b) {
    a.Swap(&b);
  }
  inline void Swap(SumOptions* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SumOptions* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SumOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SumOptions>(arena);
  }
  SumOptions* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SumOptions& from);
  void MergeFrom(const SumOptions& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SumOptions* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.SumOptions";
  }
  protected:
  explicit SumOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kStatNameFieldNumber = 1,
    kIncludeCumulativeSumFieldNumber = 2,
    kIncludeClientSamplesFieldNumber = 3,
  };
  // string stat_name = 1;
  void clear_stat_name();
  const std::string& stat_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_stat_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_stat_name();
  PROTOBUF_NODISCARD std::string* release_stat_name();
  void set_allocated_stat_name(std::string* stat_name);
  private:
  const std::string& _internal_stat_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_stat_name(const std::string& value);
  std::string* _internal_mutable_stat_name();
  public:

  // bool include_cumulative_sum = 2;
  void clear_include_cumulative_sum();
  bool include_cumulative_sum() const;
  void set_include_cumulative_sum(bool value);
  private:
  bool _internal_include_cumulative_sum() const;
  void _internal_set_include_cumulative_sum(bool value);
  public:

  // bool include_client_samples = 3;
  void clear_include_client_samples();
  bool include_client_samples() const;
  void set_include_client_samples(bool value);
  private:
  bool _internal_include_client_samples() const;
  void _internal_set_include_client_samples(bool value);
  public:

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.SumOptions)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr stat_name_;
    bool include_cumulative_sum_;
    bool include_client_samples_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class AverageOptions final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.AverageOptions) */ {
 public:
  inline AverageOptions() : AverageOptions(nullptr) {}
  ~AverageOptions() override;
  explicit PROTOBUF_CONSTEXPR AverageOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  AverageOptions(const AverageOptions& from);
  AverageOptions(AverageOptions&& from) noexcept
    : AverageOptions() {
    *this = ::std::move(from);
  }

  inline AverageOptions& operator=(const AverageOptions& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline AverageOptions& operator=(AverageOptions&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const AverageOptions& default_instance() {
    return *internal_default_instance();
  }
  static inline const AverageOptions* internal_default_instance() {
    return reinterpret_cast<const AverageOptions*>(
               &_AverageOptions_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(AverageOptions& a, AverageOptions& b) {
    a.Swap(&b);
  }
  inline void Swap(AverageOptions* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AverageOptions* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  AverageOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AverageOptions>(arena);
  }
  AverageOptions* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const AverageOptions& from);
  void MergeFrom(const AverageOptions& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(AverageOptions* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.AverageOptions";
  }
  protected:
  explicit AverageOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kNumeratorStatNameFieldNumber = 1,
    kDenominatorStatNameFieldNumber = 2,
    kAverageStatNameFieldNumber = 3,
    kIncludeClientSamplesFieldNumber = 4,
  };
  // string numerator_stat_name = 1;
  void clear_numerator_stat_name();
  const std::string& numerator_stat_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_numerator_stat_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_numerator_stat_name();
  PROTOBUF_NODISCARD std::string* release_numerator_stat_name();
  void set_allocated_numerator_stat_name(std::string* numerator_stat_name);
  private:
  const std::string& _internal_numerator_stat_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_numerator_stat_name(const std::string& value);
  std::string* _internal_mutable_numerator_stat_name();
  public:

  // string denominator_stat_name = 2;
  void clear_denominator_stat_name();
  const std::string& denominator_stat_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_denominator_stat_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_denominator_stat_name();
  PROTOBUF_NODISCARD std::string* release_denominator_stat_name();
  void set_allocated_denominator_stat_name(std::string* denominator_stat_name);
  private:
  const std::string& _internal_denominator_stat_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_denominator_stat_name(const std::string& value);
  std::string* _internal_mutable_denominator_stat_name();
  public:

  // string average_stat_name = 3;
  void clear_average_stat_name();
  const std::string& average_stat_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_average_stat_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_average_stat_name();
  PROTOBUF_NODISCARD std::string* release_average_stat_name();
  void set_allocated_average_stat_name(std::string* average_stat_name);
  private:
  const std::string& _internal_average_stat_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_average_stat_name(const std::string& value);
  std::string* _internal_mutable_average_stat_name();
  public:

  // bool include_client_samples = 4;
  void clear_include_client_samples();
  bool include_client_samples() const;
  void set_include_client_samples(bool value);
  private:
  bool _internal_include_client_samples() const;
  void _internal_set_include_client_samples(bool value);
  public:

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.AverageOptions)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr numerator_stat_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr denominator_stat_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr average_stat_name_;
    bool include_client_samples_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class NoneOptions final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.NoneOptions) */ {
 public:
  inline NoneOptions() : NoneOptions(nullptr) {}
  ~NoneOptions() override;
  explicit PROTOBUF_CONSTEXPR NoneOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  NoneOptions(const NoneOptions& from);
  NoneOptions(NoneOptions&& from) noexcept
    : NoneOptions() {
    *this = ::std::move(from);
  }

  inline NoneOptions& operator=(const NoneOptions& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline NoneOptions& operator=(NoneOptions&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const NoneOptions& default_instance() {
    return *internal_default_instance();
  }
  static inline const NoneOptions* internal_default_instance() {
    return reinterpret_cast<const NoneOptions*>(
               &_NoneOptions_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(NoneOptions& a, NoneOptions& b) {
    a.Swap(&b);
  }
  inline void Swap(NoneOptions* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NoneOptions* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  NoneOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<NoneOptions>(arena);
  }
  NoneOptions* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const NoneOptions& from);
  void MergeFrom(const NoneOptions& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(NoneOptions* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.NoneOptions";
  }
  protected:
  explicit NoneOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kStatNameFieldNumber = 1,
  };
  // string stat_name = 1;
  void clear_stat_name();
  const std::string& stat_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_stat_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_stat_name();
  PROTOBUF_NODISCARD std::string* release_stat_name();
  void set_allocated_stat_name(std::string* stat_name);
  private:
  const std::string& _internal_stat_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_stat_name(const std::string& value);
  std::string* _internal_mutable_stat_name();
  public:

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.NoneOptions)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr stat_name_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class OnlySampleOptions final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.OnlySampleOptions) */ {
 public:
  inline OnlySampleOptions() : OnlySampleOptions(nullptr) {}
  ~OnlySampleOptions() override;
  explicit PROTOBUF_CONSTEXPR OnlySampleOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  OnlySampleOptions(const OnlySampleOptions& from);
  OnlySampleOptions(OnlySampleOptions&& from) noexcept
    : OnlySampleOptions() {
    *this = ::std::move(from);
  }

  inline OnlySampleOptions& operator=(const OnlySampleOptions& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline OnlySampleOptions& operator=(OnlySampleOptions&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const OnlySampleOptions& default_instance() {
    return *internal_default_instance();
  }
  static inline const OnlySampleOptions* internal_default_instance() {
    return reinterpret_cast<const OnlySampleOptions*>(
               &_OnlySampleOptions_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(OnlySampleOptions& a, OnlySampleOptions& b) {
    a.Swap(&b);
  }
  inline void Swap(OnlySampleOptions* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(OnlySampleOptions* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  OnlySampleOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<OnlySampleOptions>(arena);
  }
  OnlySampleOptions* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const OnlySampleOptions& from);
  void MergeFrom(const OnlySampleOptions& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(OnlySampleOptions* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.OnlySampleOptions";
  }
  protected:
  explicit OnlySampleOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kStatNameFieldNumber = 1,
  };
  // string stat_name = 1;
  void clear_stat_name();
  const std::string& stat_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_stat_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_stat_name();
  PROTOBUF_NODISCARD std::string* release_stat_name();
  void set_allocated_stat_name(std::string* stat_name);
  private:
  const std::string& _internal_stat_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_stat_name(const std::string& value);
  std::string* _internal_mutable_stat_name();
  public:

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.OnlySampleOptions)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr stat_name_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class Dataset_ClientDataset_SelectedExample final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.Dataset.ClientDataset.SelectedExample) */ {
 public:
  inline Dataset_ClientDataset_SelectedExample() : Dataset_ClientDataset_SelectedExample(nullptr) {}
  ~Dataset_ClientDataset_SelectedExample() override;
  explicit PROTOBUF_CONSTEXPR Dataset_ClientDataset_SelectedExample(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Dataset_ClientDataset_SelectedExample(const Dataset_ClientDataset_SelectedExample& from);
  Dataset_ClientDataset_SelectedExample(Dataset_ClientDataset_SelectedExample&& from) noexcept
    : Dataset_ClientDataset_SelectedExample() {
    *this = ::std::move(from);
  }

  inline Dataset_ClientDataset_SelectedExample& operator=(const Dataset_ClientDataset_SelectedExample& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline Dataset_ClientDataset_SelectedExample& operator=(Dataset_ClientDataset_SelectedExample&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const Dataset_ClientDataset_SelectedExample& default_instance() {
    return *internal_default_instance();
  }
  static inline const Dataset_ClientDataset_SelectedExample* internal_default_instance() {
    return reinterpret_cast<const Dataset_ClientDataset_SelectedExample*>(
               &_Dataset_ClientDataset_SelectedExample_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  friend void swap(Dataset_ClientDataset_SelectedExample& a, Dataset_ClientDataset_SelectedExample& b) {
    a.Swap(&b);
  }
  inline void Swap(Dataset_ClientDataset_SelectedExample* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Dataset_ClientDataset_SelectedExample* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Dataset_ClientDataset_SelectedExample* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Dataset_ClientDataset_SelectedExample>(arena);
  }
  Dataset_ClientDataset_SelectedExample* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const Dataset_ClientDataset_SelectedExample& from);
  void MergeFrom(const Dataset_ClientDataset_SelectedExample& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Dataset_ClientDataset_SelectedExample* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.Dataset.ClientDataset.SelectedExample";
  }
  protected:
  explicit Dataset_ClientDataset_SelectedExample(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kExampleFieldNumber = 2,
    kSelectorFieldNumber = 1,
  };
  // repeated bytes example = 2;
  int example_size() const;
  private:
  int _internal_example_size() const;
  public:
  void clear_example();
  const std::string& example(int index) const;
  std::string* mutable_example(int index);
  void set_example(int index, const std::string& value);
  void set_example(int index, std::string&& value);
  void set_example(int index, const char* value);
  void set_example(int index, const void* value, size_t size);
  std::string* add_example();
  void add_example(const std::string& value);
  void add_example(std::string&& value);
  void add_example(const char* value);
  void add_example(const void* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& example() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_example();
  private:
  const std::string& _internal_example(int index) const;
  std::string* _internal_add_example();
  public:

  // .google.internal.federated.plan.ExampleSelector selector = 1;
  bool has_selector() const;
  private:
  bool _internal_has_selector() const;
  public:
  void clear_selector();
  const ::google::internal::federated::plan::ExampleSelector& selector() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::ExampleSelector* release_selector();
  ::google::internal::federated::plan::ExampleSelector* mutable_selector();
  void set_allocated_selector(::google::internal::federated::plan::ExampleSelector* selector);
  private:
  const ::google::internal::federated::plan::ExampleSelector& _internal_selector() const;
  ::google::internal::federated::plan::ExampleSelector* _internal_mutable_selector();
  public:
  void unsafe_arena_set_allocated_selector(
      ::google::internal::federated::plan::ExampleSelector* selector);
  ::google::internal::federated::plan::ExampleSelector* unsafe_arena_release_selector();

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.Dataset.ClientDataset.SelectedExample)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> example_;
    ::google::internal::federated::plan::ExampleSelector* selector_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class Dataset_ClientDataset final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.Dataset.ClientDataset) */ {
 public:
  inline Dataset_ClientDataset() : Dataset_ClientDataset(nullptr) {}
  ~Dataset_ClientDataset() override;
  explicit PROTOBUF_CONSTEXPR Dataset_ClientDataset(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Dataset_ClientDataset(const Dataset_ClientDataset& from);
  Dataset_ClientDataset(Dataset_ClientDataset&& from) noexcept
    : Dataset_ClientDataset() {
    *this = ::std::move(from);
  }

  inline Dataset_ClientDataset& operator=(const Dataset_ClientDataset& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline Dataset_ClientDataset& operator=(Dataset_ClientDataset&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const Dataset_ClientDataset& default_instance() {
    return *internal_default_instance();
  }
  static inline const Dataset_ClientDataset* internal_default_instance() {
    return reinterpret_cast<const Dataset_ClientDataset*>(
               &_Dataset_ClientDataset_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

  friend void swap(Dataset_ClientDataset& a, Dataset_ClientDataset& b) {
    a.Swap(&b);
  }
  inline void Swap(Dataset_ClientDataset* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Dataset_ClientDataset* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Dataset_ClientDataset* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Dataset_ClientDataset>(arena);
  }
  Dataset_ClientDataset* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const Dataset_ClientDataset& from);
  void MergeFrom(const Dataset_ClientDataset& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Dataset_ClientDataset* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.Dataset.ClientDataset";
  }
  protected:
  explicit Dataset_ClientDataset(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

  typedef Dataset_ClientDataset_SelectedExample SelectedExample;

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

  enum : int {
    kExampleFieldNumber = 2,
    kSelectedExampleFieldNumber = 3,
    kClientIdFieldNumber = 1,
  };
  // repeated bytes example = 2;
  int example_size() const;
  private:
  int _internal_example_size() const;
  public:
  void clear_example();
  const std::string& example(int index) const;
  std::string* mutable_example(int index);
  void set_example(int index, const std::string& value);
  void set_example(int index, std::string&& value);
  void set_example(int index, const char* value);
  void set_example(int index, const void* value, size_t size);
  std::string* add_example();
  void add_example(const std::string& value);
  void add_example(std::string&& value);
  void add_example(const char* value);
  void add_example(const void* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& example() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_example();
  private:
  const std::string& _internal_example(int index) const;
  std::string* _internal_add_example();
  public:

  // repeated .google.internal.federated.plan.Dataset.ClientDataset.SelectedExample selected_example = 3;
  int selected_example_size() const;
  private:
  int _internal_selected_example_size() const;
  public:
  void clear_selected_example();
  ::google::internal::federated::plan::Dataset_ClientDataset_SelectedExample* mutable_selected_example(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::Dataset_ClientDataset_SelectedExample >*
      mutable_selected_example();
  private:
  const ::google::internal::federated::plan::Dataset_ClientDataset_SelectedExample& _internal_selected_example(int index) const;
  ::google::internal::federated::plan::Dataset_ClientDataset_SelectedExample* _internal_add_selected_example();
  public:
  const ::google::internal::federated::plan::Dataset_ClientDataset_SelectedExample& selected_example(int index) const;
  ::google::internal::federated::plan::Dataset_ClientDataset_SelectedExample* add_selected_example();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::Dataset_ClientDataset_SelectedExample >&
      selected_example() const;

  // string client_id = 1;
  void clear_client_id();
  const std::string& client_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_client_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_client_id();
  PROTOBUF_NODISCARD std::string* release_client_id();
  void set_allocated_client_id(std::string* client_id);
  private:
  const std::string& _internal_client_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_client_id(const std::string& value);
  std::string* _internal_mutable_client_id();
  public:

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.Dataset.ClientDataset)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> example_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::Dataset_ClientDataset_SelectedExample > selected_example_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_id_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class Dataset final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.Dataset) */ {
 public:
  inline Dataset() : Dataset(nullptr) {}
  ~Dataset() override;
  explicit PROTOBUF_CONSTEXPR Dataset(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Dataset(const Dataset& from);
  Dataset(Dataset&& from) noexcept
    : Dataset() {
    *this = ::std::move(from);
  }

  inline Dataset& operator=(const Dataset& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline Dataset& operator=(Dataset&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const Dataset& default_instance() {
    return *internal_default_instance();
  }
  static inline const Dataset* internal_default_instance() {
    return reinterpret_cast<const Dataset*>(
               &_Dataset_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;

  friend void swap(Dataset& a, Dataset& b) {
    a.Swap(&b);
  }
  inline void Swap(Dataset* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Dataset* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Dataset* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Dataset>(arena);
  }
  Dataset* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const Dataset& from);
  void MergeFrom(const Dataset& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Dataset* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.Dataset";
  }
  protected:
  explicit Dataset(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

  typedef Dataset_ClientDataset ClientDataset;

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

  enum : int {
    kClientDataFieldNumber = 1,
  };
  // repeated .google.internal.federated.plan.Dataset.ClientDataset client_data = 1;
  int client_data_size() const;
  private:
  int _internal_client_data_size() const;
  public:
  void clear_client_data();
  ::google::internal::federated::plan::Dataset_ClientDataset* mutable_client_data(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::Dataset_ClientDataset >*
      mutable_client_data();
  private:
  const ::google::internal::federated::plan::Dataset_ClientDataset& _internal_client_data(int index) const;
  ::google::internal::federated::plan::Dataset_ClientDataset* _internal_add_client_data();
  public:
  const ::google::internal::federated::plan::Dataset_ClientDataset& client_data(int index) const;
  ::google::internal::federated::plan::Dataset_ClientDataset* add_client_data();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::Dataset_ClientDataset >&
      client_data() const;

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.Dataset)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::Dataset_ClientDataset > client_data_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class MetricTestPredicates_Interval final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.MetricTestPredicates.Interval) */ {
 public:
  inline MetricTestPredicates_Interval() : MetricTestPredicates_Interval(nullptr) {}
  ~MetricTestPredicates_Interval() override;
  explicit PROTOBUF_CONSTEXPR MetricTestPredicates_Interval(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MetricTestPredicates_Interval(const MetricTestPredicates_Interval& from);
  MetricTestPredicates_Interval(MetricTestPredicates_Interval&& from) noexcept
    : MetricTestPredicates_Interval() {
    *this = ::std::move(from);
  }

  inline MetricTestPredicates_Interval& operator=(const MetricTestPredicates_Interval& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline MetricTestPredicates_Interval& operator=(MetricTestPredicates_Interval&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const MetricTestPredicates_Interval& default_instance() {
    return *internal_default_instance();
  }
  static inline const MetricTestPredicates_Interval* internal_default_instance() {
    return reinterpret_cast<const MetricTestPredicates_Interval*>(
               &_MetricTestPredicates_Interval_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    17;

  friend void swap(MetricTestPredicates_Interval& a, MetricTestPredicates_Interval& b) {
    a.Swap(&b);
  }
  inline void Swap(MetricTestPredicates_Interval* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MetricTestPredicates_Interval* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  MetricTestPredicates_Interval* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MetricTestPredicates_Interval>(arena);
  }
  MetricTestPredicates_Interval* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const MetricTestPredicates_Interval& from);
  void MergeFrom(const MetricTestPredicates_Interval& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(MetricTestPredicates_Interval* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.MetricTestPredicates.Interval";
  }
  protected:
  explicit MetricTestPredicates_Interval(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kLowerBoundFieldNumber = 1,
    kUpperBoundFieldNumber = 2,
  };
  // double lower_bound = 1;
  void clear_lower_bound();
  double lower_bound() const;
  void set_lower_bound(double value);
  private:
  double _internal_lower_bound() const;
  void _internal_set_lower_bound(double value);
  public:

  // double upper_bound = 2;
  void clear_upper_bound();
  double upper_bound() const;
  void set_upper_bound(double value);
  private:
  double _internal_upper_bound() const;
  void _internal_set_upper_bound(double value);
  public:

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.MetricTestPredicates.Interval)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    double lower_bound_;
    double upper_bound_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class MetricTestPredicates_RealIfNonzeroWeight final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.MetricTestPredicates.RealIfNonzeroWeight) */ {
 public:
  inline MetricTestPredicates_RealIfNonzeroWeight() : MetricTestPredicates_RealIfNonzeroWeight(nullptr) {}
  ~MetricTestPredicates_RealIfNonzeroWeight() override;
  explicit PROTOBUF_CONSTEXPR MetricTestPredicates_RealIfNonzeroWeight(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MetricTestPredicates_RealIfNonzeroWeight(const MetricTestPredicates_RealIfNonzeroWeight& from);
  MetricTestPredicates_RealIfNonzeroWeight(MetricTestPredicates_RealIfNonzeroWeight&& from) noexcept
    : MetricTestPredicates_RealIfNonzeroWeight() {
    *this = ::std::move(from);
  }

  inline MetricTestPredicates_RealIfNonzeroWeight& operator=(const MetricTestPredicates_RealIfNonzeroWeight& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline MetricTestPredicates_RealIfNonzeroWeight& operator=(MetricTestPredicates_RealIfNonzeroWeight&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const MetricTestPredicates_RealIfNonzeroWeight& default_instance() {
    return *internal_default_instance();
  }
  static inline const MetricTestPredicates_RealIfNonzeroWeight* internal_default_instance() {
    return reinterpret_cast<const MetricTestPredicates_RealIfNonzeroWeight*>(
               &_MetricTestPredicates_RealIfNonzeroWeight_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    18;

  friend void swap(MetricTestPredicates_RealIfNonzeroWeight& a, MetricTestPredicates_RealIfNonzeroWeight& b) {
    a.Swap(&b);
  }
  inline void Swap(MetricTestPredicates_RealIfNonzeroWeight* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MetricTestPredicates_RealIfNonzeroWeight* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  MetricTestPredicates_RealIfNonzeroWeight* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MetricTestPredicates_RealIfNonzeroWeight>(arena);
  }
  MetricTestPredicates_RealIfNonzeroWeight* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const MetricTestPredicates_RealIfNonzeroWeight& from);
  void MergeFrom(const MetricTestPredicates_RealIfNonzeroWeight& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(MetricTestPredicates_RealIfNonzeroWeight* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.MetricTestPredicates.RealIfNonzeroWeight";
  }
  protected:
  explicit MetricTestPredicates_RealIfNonzeroWeight(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kWeightNameFieldNumber = 1,
  };
  // string weight_name = 1;
  void clear_weight_name();
  const std::string& weight_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_weight_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_weight_name();
  PROTOBUF_NODISCARD std::string* release_weight_name();
  void set_allocated_weight_name(std::string* weight_name);
  private:
  const std::string& _internal_weight_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_weight_name(const std::string& value);
  std::string* _internal_mutable_weight_name();
  public:

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.MetricTestPredicates.RealIfNonzeroWeight)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr weight_name_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class MetricTestPredicates_MetricCriterion final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.MetricTestPredicates.MetricCriterion) */ {
 public:
  inline MetricTestPredicates_MetricCriterion() : MetricTestPredicates_MetricCriterion(nullptr) {}
  ~MetricTestPredicates_MetricCriterion() override;
  explicit PROTOBUF_CONSTEXPR MetricTestPredicates_MetricCriterion(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MetricTestPredicates_MetricCriterion(const MetricTestPredicates_MetricCriterion& from);
  MetricTestPredicates_MetricCriterion(MetricTestPredicates_MetricCriterion&& from) noexcept
    : MetricTestPredicates_MetricCriterion() {
    *this = ::std::move(from);
  }

  inline MetricTestPredicates_MetricCriterion& operator=(const MetricTestPredicates_MetricCriterion& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline MetricTestPredicates_MetricCriterion& operator=(MetricTestPredicates_MetricCriterion&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const MetricTestPredicates_MetricCriterion& default_instance() {
    return *internal_default_instance();
  }
  enum CriterionCase {
    kLt = 3,
    kGt = 4,
    kLe = 5,
    kGe = 6,
    kEq = 7,
    kInterval = 8,
    kReal = 9,
    kRealIfNonzeroWeight = 10,
    CRITERION_NOT_SET = 0,
  };

  static inline const MetricTestPredicates_MetricCriterion* internal_default_instance() {
    return reinterpret_cast<const MetricTestPredicates_MetricCriterion*>(
               &_MetricTestPredicates_MetricCriterion_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    19;

  friend void swap(MetricTestPredicates_MetricCriterion& a, MetricTestPredicates_MetricCriterion& b) {
    a.Swap(&b);
  }
  inline void Swap(MetricTestPredicates_MetricCriterion* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MetricTestPredicates_MetricCriterion* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  MetricTestPredicates_MetricCriterion* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MetricTestPredicates_MetricCriterion>(arena);
  }
  MetricTestPredicates_MetricCriterion* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const MetricTestPredicates_MetricCriterion& from);
  void MergeFrom(const MetricTestPredicates_MetricCriterion& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(MetricTestPredicates_MetricCriterion* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.MetricTestPredicates.MetricCriterion";
  }
  protected:
  explicit MetricTestPredicates_MetricCriterion(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kNameFieldNumber = 1,
    kTrainingRoundIndexFieldNumber = 2,
    kLtFieldNumber = 3,
    kGtFieldNumber = 4,
    kLeFieldNumber = 5,
    kGeFieldNumber = 6,
    kEqFieldNumber = 7,
    kIntervalFieldNumber = 8,
    kRealFieldNumber = 9,
    kRealIfNonzeroWeightFieldNumber = 10,
  };
  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // int32 training_round_index = 2;
  void clear_training_round_index();
  ::int32_t training_round_index() const;
  void set_training_round_index(::int32_t value);
  private:
  ::int32_t _internal_training_round_index() const;
  void _internal_set_training_round_index(::int32_t value);
  public:

  // float lt = 3;
  bool has_lt() const;
  private:
  bool _internal_has_lt() const;
  public:
  void clear_lt();
  float lt() const;
  void set_lt(float value);
  private:
  float _internal_lt() const;
  void _internal_set_lt(float value);
  public:

  // float gt = 4;
  bool has_gt() const;
  private:
  bool _internal_has_gt() const;
  public:
  void clear_gt();
  float gt() const;
  void set_gt(float value);
  private:
  float _internal_gt() const;
  void _internal_set_gt(float value);
  public:

  // float le = 5;
  bool has_le() const;
  private:
  bool _internal_has_le() const;
  public:
  void clear_le();
  float le() const;
  void set_le(float value);
  private:
  float _internal_le() const;
  void _internal_set_le(float value);
  public:

  // float ge = 6;
  bool has_ge() const;
  private:
  bool _internal_has_ge() const;
  public:
  void clear_ge();
  float ge() const;
  void set_ge(float value);
  private:
  float _internal_ge() const;
  void _internal_set_ge(float value);
  public:

  // float eq = 7;
  bool has_eq() const;
  private:
  bool _internal_has_eq() const;
  public:
  void clear_eq();
  float eq() const;
  void set_eq(float value);
  private:
  float _internal_eq() const;
  void _internal_set_eq(float value);
  public:

  // .google.internal.federated.plan.MetricTestPredicates.Interval interval = 8;
  bool has_interval() const;
  private:
  bool _internal_has_interval() const;
  public:
  void clear_interval();
  const ::google::internal::federated::plan::MetricTestPredicates_Interval& interval() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::MetricTestPredicates_Interval* release_interval();
  ::google::internal::federated::plan::MetricTestPredicates_Interval* mutable_interval();
  void set_allocated_interval(::google::internal::federated::plan::MetricTestPredicates_Interval* interval);
  private:
  const ::google::internal::federated::plan::MetricTestPredicates_Interval& _internal_interval() const;
  ::google::internal::federated::plan::MetricTestPredicates_Interval* _internal_mutable_interval();
  public:
  void unsafe_arena_set_allocated_interval(
      ::google::internal::federated::plan::MetricTestPredicates_Interval* interval);
  ::google::internal::federated::plan::MetricTestPredicates_Interval* unsafe_arena_release_interval();

  // bool real = 9;
  bool has_real() const;
  private:
  bool _internal_has_real() const;
  public:
  void clear_real();
  bool real() const;
  void set_real(bool value);
  private:
  bool _internal_real() const;
  void _internal_set_real(bool value);
  public:

  // .google.internal.federated.plan.MetricTestPredicates.RealIfNonzeroWeight real_if_nonzero_weight = 10;
  bool has_real_if_nonzero_weight() const;
  private:
  bool _internal_has_real_if_nonzero_weight() const;
  public:
  void clear_real_if_nonzero_weight();
  const ::google::internal::federated::plan::MetricTestPredicates_RealIfNonzeroWeight& real_if_nonzero_weight() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::MetricTestPredicates_RealIfNonzeroWeight* release_real_if_nonzero_weight();
  ::google::internal::federated::plan::MetricTestPredicates_RealIfNonzeroWeight* mutable_real_if_nonzero_weight();
  void set_allocated_real_if_nonzero_weight(::google::internal::federated::plan::MetricTestPredicates_RealIfNonzeroWeight* real_if_nonzero_weight);
  private:
  const ::google::internal::federated::plan::MetricTestPredicates_RealIfNonzeroWeight& _internal_real_if_nonzero_weight() const;
  ::google::internal::federated::plan::MetricTestPredicates_RealIfNonzeroWeight* _internal_mutable_real_if_nonzero_weight();
  public:
  void unsafe_arena_set_allocated_real_if_nonzero_weight(
      ::google::internal::federated::plan::MetricTestPredicates_RealIfNonzeroWeight* real_if_nonzero_weight);
  ::google::internal::federated::plan::MetricTestPredicates_RealIfNonzeroWeight* unsafe_arena_release_real_if_nonzero_weight();

  void clear_Criterion();
  CriterionCase Criterion_case() const;
  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.MetricTestPredicates.MetricCriterion)
 private:
  class _Internal;
  void set_has_lt();
  void set_has_gt();
  void set_has_le();
  void set_has_ge();
  void set_has_eq();
  void set_has_interval();
  void set_has_real();
  void set_has_real_if_nonzero_weight();

  inline bool has_Criterion() const;
  inline void clear_has_Criterion();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::int32_t training_round_index_;
    union CriterionUnion {
      constexpr CriterionUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      float lt_;
      float gt_;
      float le_;
      float ge_;
      float eq_;
      ::google::internal::federated::plan::MetricTestPredicates_Interval* interval_;
      bool real_;
      ::google::internal::federated::plan::MetricTestPredicates_RealIfNonzeroWeight* real_if_nonzero_weight_;
    } Criterion_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class MetricTestPredicates final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.MetricTestPredicates) */ {
 public:
  inline MetricTestPredicates() : MetricTestPredicates(nullptr) {}
  ~MetricTestPredicates() override;
  explicit PROTOBUF_CONSTEXPR MetricTestPredicates(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MetricTestPredicates(const MetricTestPredicates& from);
  MetricTestPredicates(MetricTestPredicates&& from) noexcept
    : MetricTestPredicates() {
    *this = ::std::move(from);
  }

  inline MetricTestPredicates& operator=(const MetricTestPredicates& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline MetricTestPredicates& operator=(MetricTestPredicates&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const MetricTestPredicates& default_instance() {
    return *internal_default_instance();
  }
  static inline const MetricTestPredicates* internal_default_instance() {
    return reinterpret_cast<const MetricTestPredicates*>(
               &_MetricTestPredicates_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    20;

  friend void swap(MetricTestPredicates& a, MetricTestPredicates& b) {
    a.Swap(&b);
  }
  inline void Swap(MetricTestPredicates* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MetricTestPredicates* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  MetricTestPredicates* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MetricTestPredicates>(arena);
  }
  MetricTestPredicates* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const MetricTestPredicates& from);
  void MergeFrom(const MetricTestPredicates& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(MetricTestPredicates* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.MetricTestPredicates";
  }
  protected:
  explicit MetricTestPredicates(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

  typedef MetricTestPredicates_Interval Interval;
  typedef MetricTestPredicates_RealIfNonzeroWeight RealIfNonzeroWeight;
  typedef MetricTestPredicates_MetricCriterion MetricCriterion;

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

  enum : int {
    kMetricCriterionFieldNumber = 1,
  };
  // repeated .google.internal.federated.plan.MetricTestPredicates.MetricCriterion metric_criterion = 1;
  int metric_criterion_size() const;
  private:
  int _internal_metric_criterion_size() const;
  public:
  void clear_metric_criterion();
  ::google::internal::federated::plan::MetricTestPredicates_MetricCriterion* mutable_metric_criterion(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::MetricTestPredicates_MetricCriterion >*
      mutable_metric_criterion();
  private:
  const ::google::internal::federated::plan::MetricTestPredicates_MetricCriterion& _internal_metric_criterion(int index) const;
  ::google::internal::federated::plan::MetricTestPredicates_MetricCriterion* _internal_add_metric_criterion();
  public:
  const ::google::internal::federated::plan::MetricTestPredicates_MetricCriterion& metric_criterion(int index) const;
  ::google::internal::federated::plan::MetricTestPredicates_MetricCriterion* add_metric_criterion();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::MetricTestPredicates_MetricCriterion >&
      metric_criterion() const;

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.MetricTestPredicates)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::MetricTestPredicates_MetricCriterion > metric_criterion_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class ClientPhase final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.ClientPhase) */ {
 public:
  inline ClientPhase() : ClientPhase(nullptr) {}
  ~ClientPhase() override;
  explicit PROTOBUF_CONSTEXPR ClientPhase(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ClientPhase(const ClientPhase& from);
  ClientPhase(ClientPhase&& from) noexcept
    : ClientPhase() {
    *this = ::std::move(from);
  }

  inline ClientPhase& operator=(const ClientPhase& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline ClientPhase& operator=(ClientPhase&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ClientPhase& default_instance() {
    return *internal_default_instance();
  }
  enum SpecCase {
    kTensorflowSpec = 4,
    kExampleQuerySpec = 9,
    SPEC_NOT_SET = 0,
  };

  enum IoRouterCase {
    kFederatedCompute = 5,
    kLocalCompute = 6,
    kFederatedComputeEligibility = 7,
    kFederatedExampleQuery = 8,
    IO_ROUTER_NOT_SET = 0,
  };

  static inline const ClientPhase* internal_default_instance() {
    return reinterpret_cast<const ClientPhase*>(
               &_ClientPhase_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    21;

  friend void swap(ClientPhase& a, ClientPhase& b) {
    a.Swap(&b);
  }
  inline void Swap(ClientPhase* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ClientPhase* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ClientPhase* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ClientPhase>(arena);
  }
  ClientPhase* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const ClientPhase& from);
  void MergeFrom(const ClientPhase& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ClientPhase* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.ClientPhase";
  }
  protected:
  explicit ClientPhase(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kNameFieldNumber = 2,
    kMinimumNumberOfParticipantsFieldNumber = 3,
    kTensorflowSpecFieldNumber = 4,
    kExampleQuerySpecFieldNumber = 9,
    kFederatedComputeFieldNumber = 5,
    kLocalComputeFieldNumber = 6,
    kFederatedComputeEligibilityFieldNumber = 7,
    kFederatedExampleQueryFieldNumber = 8,
  };
  // string name = 2;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // int32 minimum_number_of_participants = 3;
  void clear_minimum_number_of_participants();
  ::int32_t minimum_number_of_participants() const;
  void set_minimum_number_of_participants(::int32_t value);
  private:
  ::int32_t _internal_minimum_number_of_participants() const;
  void _internal_set_minimum_number_of_participants(::int32_t value);
  public:

  // .google.internal.federated.plan.TensorflowSpec tensorflow_spec = 4 [lazy = true];
  bool has_tensorflow_spec() const;
  private:
  bool _internal_has_tensorflow_spec() const;
  public:
  void clear_tensorflow_spec();
  const ::google::internal::federated::plan::TensorflowSpec& tensorflow_spec() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::TensorflowSpec* release_tensorflow_spec();
  ::google::internal::federated::plan::TensorflowSpec* mutable_tensorflow_spec();
  void set_allocated_tensorflow_spec(::google::internal::federated::plan::TensorflowSpec* tensorflow_spec);
  private:
  const ::google::internal::federated::plan::TensorflowSpec& _internal_tensorflow_spec() const;
  ::google::internal::federated::plan::TensorflowSpec* _internal_mutable_tensorflow_spec();
  public:
  void unsafe_arena_set_allocated_tensorflow_spec(
      ::google::internal::federated::plan::TensorflowSpec* tensorflow_spec);
  ::google::internal::federated::plan::TensorflowSpec* unsafe_arena_release_tensorflow_spec();

  // .google.internal.federated.plan.ExampleQuerySpec example_query_spec = 9 [lazy = true];
  bool has_example_query_spec() const;
  private:
  bool _internal_has_example_query_spec() const;
  public:
  void clear_example_query_spec();
  const ::google::internal::federated::plan::ExampleQuerySpec& example_query_spec() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::ExampleQuerySpec* release_example_query_spec();
  ::google::internal::federated::plan::ExampleQuerySpec* mutable_example_query_spec();
  void set_allocated_example_query_spec(::google::internal::federated::plan::ExampleQuerySpec* example_query_spec);
  private:
  const ::google::internal::federated::plan::ExampleQuerySpec& _internal_example_query_spec() const;
  ::google::internal::federated::plan::ExampleQuerySpec* _internal_mutable_example_query_spec();
  public:
  void unsafe_arena_set_allocated_example_query_spec(
      ::google::internal::federated::plan::ExampleQuerySpec* example_query_spec);
  ::google::internal::federated::plan::ExampleQuerySpec* unsafe_arena_release_example_query_spec();

  // .google.internal.federated.plan.FederatedComputeIORouter federated_compute = 5 [lazy = true];
  bool has_federated_compute() const;
  private:
  bool _internal_has_federated_compute() const;
  public:
  void clear_federated_compute();
  const ::google::internal::federated::plan::FederatedComputeIORouter& federated_compute() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::FederatedComputeIORouter* release_federated_compute();
  ::google::internal::federated::plan::FederatedComputeIORouter* mutable_federated_compute();
  void set_allocated_federated_compute(::google::internal::federated::plan::FederatedComputeIORouter* federated_compute);
  private:
  const ::google::internal::federated::plan::FederatedComputeIORouter& _internal_federated_compute() const;
  ::google::internal::federated::plan::FederatedComputeIORouter* _internal_mutable_federated_compute();
  public:
  void unsafe_arena_set_allocated_federated_compute(
      ::google::internal::federated::plan::FederatedComputeIORouter* federated_compute);
  ::google::internal::federated::plan::FederatedComputeIORouter* unsafe_arena_release_federated_compute();

  // .google.internal.federated.plan.LocalComputeIORouter local_compute = 6 [lazy = true];
  bool has_local_compute() const;
  private:
  bool _internal_has_local_compute() const;
  public:
  void clear_local_compute();
  const ::google::internal::federated::plan::LocalComputeIORouter& local_compute() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::LocalComputeIORouter* release_local_compute();
  ::google::internal::federated::plan::LocalComputeIORouter* mutable_local_compute();
  void set_allocated_local_compute(::google::internal::federated::plan::LocalComputeIORouter* local_compute);
  private:
  const ::google::internal::federated::plan::LocalComputeIORouter& _internal_local_compute() const;
  ::google::internal::federated::plan::LocalComputeIORouter* _internal_mutable_local_compute();
  public:
  void unsafe_arena_set_allocated_local_compute(
      ::google::internal::federated::plan::LocalComputeIORouter* local_compute);
  ::google::internal::federated::plan::LocalComputeIORouter* unsafe_arena_release_local_compute();

  // .google.internal.federated.plan.FederatedComputeEligibilityIORouter federated_compute_eligibility = 7 [lazy = true];
  bool has_federated_compute_eligibility() const;
  private:
  bool _internal_has_federated_compute_eligibility() const;
  public:
  void clear_federated_compute_eligibility();
  const ::google::internal::federated::plan::FederatedComputeEligibilityIORouter& federated_compute_eligibility() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::FederatedComputeEligibilityIORouter* release_federated_compute_eligibility();
  ::google::internal::federated::plan::FederatedComputeEligibilityIORouter* mutable_federated_compute_eligibility();
  void set_allocated_federated_compute_eligibility(::google::internal::federated::plan::FederatedComputeEligibilityIORouter* federated_compute_eligibility);
  private:
  const ::google::internal::federated::plan::FederatedComputeEligibilityIORouter& _internal_federated_compute_eligibility() const;
  ::google::internal::federated::plan::FederatedComputeEligibilityIORouter* _internal_mutable_federated_compute_eligibility();
  public:
  void unsafe_arena_set_allocated_federated_compute_eligibility(
      ::google::internal::federated::plan::FederatedComputeEligibilityIORouter* federated_compute_eligibility);
  ::google::internal::federated::plan::FederatedComputeEligibilityIORouter* unsafe_arena_release_federated_compute_eligibility();

  // .google.internal.federated.plan.FederatedExampleQueryIORouter federated_example_query = 8 [lazy = true];
  bool has_federated_example_query() const;
  private:
  bool _internal_has_federated_example_query() const;
  public:
  void clear_federated_example_query();
  const ::google::internal::federated::plan::FederatedExampleQueryIORouter& federated_example_query() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::FederatedExampleQueryIORouter* release_federated_example_query();
  ::google::internal::federated::plan::FederatedExampleQueryIORouter* mutable_federated_example_query();
  void set_allocated_federated_example_query(::google::internal::federated::plan::FederatedExampleQueryIORouter* federated_example_query);
  private:
  const ::google::internal::federated::plan::FederatedExampleQueryIORouter& _internal_federated_example_query() const;
  ::google::internal::federated::plan::FederatedExampleQueryIORouter* _internal_mutable_federated_example_query();
  public:
  void unsafe_arena_set_allocated_federated_example_query(
      ::google::internal::federated::plan::FederatedExampleQueryIORouter* federated_example_query);
  ::google::internal::federated::plan::FederatedExampleQueryIORouter* unsafe_arena_release_federated_example_query();

  void clear_spec();
  SpecCase spec_case() const;
  void clear_io_router();
  IoRouterCase io_router_case() const;
  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.ClientPhase)
 private:
  class _Internal;
  void set_has_tensorflow_spec();
  void set_has_example_query_spec();
  void set_has_federated_compute();
  void set_has_local_compute();
  void set_has_federated_compute_eligibility();
  void set_has_federated_example_query();

  inline bool has_spec() const;
  inline void clear_has_spec();

  inline bool has_io_router() const;
  inline void clear_has_io_router();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::int32_t minimum_number_of_participants_;
    union SpecUnion {
      constexpr SpecUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::google::internal::federated::plan::TensorflowSpec* tensorflow_spec_;
      ::google::internal::federated::plan::ExampleQuerySpec* example_query_spec_;
    } spec_;
    union IoRouterUnion {
      constexpr IoRouterUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::google::internal::federated::plan::FederatedComputeIORouter* federated_compute_;
      ::google::internal::federated::plan::LocalComputeIORouter* local_compute_;
      ::google::internal::federated::plan::FederatedComputeEligibilityIORouter* federated_compute_eligibility_;
      ::google::internal::federated::plan::FederatedExampleQueryIORouter* federated_example_query_;
    } io_router_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[2];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class TensorflowSpec_ConstantInputsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<TensorflowSpec_ConstantInputsEntry_DoNotUse,
    std::string, ::tensorflow::TensorProto,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<TensorflowSpec_ConstantInputsEntry_DoNotUse,
    std::string, ::tensorflow::TensorProto,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  TensorflowSpec_ConstantInputsEntry_DoNotUse();
  explicit PROTOBUF_CONSTEXPR TensorflowSpec_ConstantInputsEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit TensorflowSpec_ConstantInputsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const TensorflowSpec_ConstantInputsEntry_DoNotUse& other);
  static const TensorflowSpec_ConstantInputsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const TensorflowSpec_ConstantInputsEntry_DoNotUse*>(&_TensorflowSpec_ConstantInputsEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "google.internal.federated.plan.TensorflowSpec.ConstantInputsEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};

// -------------------------------------------------------------------

class TensorflowSpec final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.TensorflowSpec) */ {
 public:
  inline TensorflowSpec() : TensorflowSpec(nullptr) {}
  ~TensorflowSpec() override;
  explicit PROTOBUF_CONSTEXPR TensorflowSpec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  TensorflowSpec(const TensorflowSpec& from);
  TensorflowSpec(TensorflowSpec&& from) noexcept
    : TensorflowSpec() {
    *this = ::std::move(from);
  }

  inline TensorflowSpec& operator=(const TensorflowSpec& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline TensorflowSpec& operator=(TensorflowSpec&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const TensorflowSpec& default_instance() {
    return *internal_default_instance();
  }
  static inline const TensorflowSpec* internal_default_instance() {
    return reinterpret_cast<const TensorflowSpec*>(
               &_TensorflowSpec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    23;

  friend void swap(TensorflowSpec& a, TensorflowSpec& b) {
    a.Swap(&b);
  }
  inline void Swap(TensorflowSpec* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TensorflowSpec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  TensorflowSpec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TensorflowSpec>(arena);
  }
  TensorflowSpec* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const TensorflowSpec& from);
  void MergeFrom(const TensorflowSpec& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(TensorflowSpec* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.TensorflowSpec";
  }
  protected:
  explicit TensorflowSpec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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


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

  enum : int {
    kInputTensorSpecsFieldNumber = 2,
    kOutputTensorSpecsFieldNumber = 3,
    kTargetNodeNamesFieldNumber = 4,
    kConstantInputsFieldNumber = 5,
    kDatasetTokenTensorNameFieldNumber = 1,
    kExampleSelectorFieldNumber = 999,
  };
  // repeated .tensorflow.TensorSpecProto input_tensor_specs = 2;
  int input_tensor_specs_size() const;
  private:
  int _internal_input_tensor_specs_size() const;
  public:
  void clear_input_tensor_specs();
  ::tensorflow::TensorSpecProto* mutable_input_tensor_specs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorSpecProto >*
      mutable_input_tensor_specs();
  private:
  const ::tensorflow::TensorSpecProto& _internal_input_tensor_specs(int index) const;
  ::tensorflow::TensorSpecProto* _internal_add_input_tensor_specs();
  public:
  const ::tensorflow::TensorSpecProto& input_tensor_specs(int index) const;
  ::tensorflow::TensorSpecProto* add_input_tensor_specs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorSpecProto >&
      input_tensor_specs() const;

  // repeated .tensorflow.TensorSpecProto output_tensor_specs = 3;
  int output_tensor_specs_size() const;
  private:
  int _internal_output_tensor_specs_size() const;
  public:
  void clear_output_tensor_specs();
  ::tensorflow::TensorSpecProto* mutable_output_tensor_specs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorSpecProto >*
      mutable_output_tensor_specs();
  private:
  const ::tensorflow::TensorSpecProto& _internal_output_tensor_specs(int index) const;
  ::tensorflow::TensorSpecProto* _internal_add_output_tensor_specs();
  public:
  const ::tensorflow::TensorSpecProto& output_tensor_specs(int index) const;
  ::tensorflow::TensorSpecProto* add_output_tensor_specs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorSpecProto >&
      output_tensor_specs() const;

  // repeated string target_node_names = 4;
  int target_node_names_size() const;
  private:
  int _internal_target_node_names_size() const;
  public:
  void clear_target_node_names();
  const std::string& target_node_names(int index) const;
  std::string* mutable_target_node_names(int index);
  void set_target_node_names(int index, const std::string& value);
  void set_target_node_names(int index, std::string&& value);
  void set_target_node_names(int index, const char* value);
  void set_target_node_names(int index, const char* value, size_t size);
  std::string* add_target_node_names();
  void add_target_node_names(const std::string& value);
  void add_target_node_names(std::string&& value);
  void add_target_node_names(const char* value);
  void add_target_node_names(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& target_node_names() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_target_node_names();
  private:
  const std::string& _internal_target_node_names(int index) const;
  std::string* _internal_add_target_node_names();
  public:

  // map<string, .tensorflow.TensorProto> constant_inputs = 5;
  int constant_inputs_size() const;
  private:
  int _internal_constant_inputs_size() const;
  public:
  void clear_constant_inputs();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::TensorProto >&
      _internal_constant_inputs() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::TensorProto >*
      _internal_mutable_constant_inputs();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::TensorProto >&
      constant_inputs() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::TensorProto >*
      mutable_constant_inputs();

  // string dataset_token_tensor_name = 1;
  void clear_dataset_token_tensor_name();
  const std::string& dataset_token_tensor_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_dataset_token_tensor_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_dataset_token_tensor_name();
  PROTOBUF_NODISCARD std::string* release_dataset_token_tensor_name();
  void set_allocated_dataset_token_tensor_name(std::string* dataset_token_tensor_name);
  private:
  const std::string& _internal_dataset_token_tensor_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_dataset_token_tensor_name(const std::string& value);
  std::string* _internal_mutable_dataset_token_tensor_name();
  public:

  // .google.internal.federated.plan.ExampleSelector example_selector = 999;
  bool has_example_selector() const;
  private:
  bool _internal_has_example_selector() const;
  public:
  void clear_example_selector();
  const ::google::internal::federated::plan::ExampleSelector& example_selector() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::ExampleSelector* release_example_selector();
  ::google::internal::federated::plan::ExampleSelector* mutable_example_selector();
  void set_allocated_example_selector(::google::internal::federated::plan::ExampleSelector* example_selector);
  private:
  const ::google::internal::federated::plan::ExampleSelector& _internal_example_selector() const;
  ::google::internal::federated::plan::ExampleSelector* _internal_mutable_example_selector();
  public:
  void unsafe_arena_set_allocated_example_selector(
      ::google::internal::federated::plan::ExampleSelector* example_selector);
  ::google::internal::federated::plan::ExampleSelector* unsafe_arena_release_example_selector();

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.TensorflowSpec)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorSpecProto > input_tensor_specs_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorSpecProto > output_tensor_specs_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> target_node_names_;
    ::PROTOBUF_NAMESPACE_ID::internal::MapFieldLite<
        TensorflowSpec_ConstantInputsEntry_DoNotUse,
        std::string, ::tensorflow::TensorProto,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> constant_inputs_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dataset_token_tensor_name_;
    ::google::internal::federated::plan::ExampleSelector* example_selector_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class ExampleQuerySpec_OutputVectorSpec final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.ExampleQuerySpec.OutputVectorSpec) */ {
 public:
  inline ExampleQuerySpec_OutputVectorSpec() : ExampleQuerySpec_OutputVectorSpec(nullptr) {}
  ~ExampleQuerySpec_OutputVectorSpec() override;
  explicit PROTOBUF_CONSTEXPR ExampleQuerySpec_OutputVectorSpec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ExampleQuerySpec_OutputVectorSpec(const ExampleQuerySpec_OutputVectorSpec& from);
  ExampleQuerySpec_OutputVectorSpec(ExampleQuerySpec_OutputVectorSpec&& from) noexcept
    : ExampleQuerySpec_OutputVectorSpec() {
    *this = ::std::move(from);
  }

  inline ExampleQuerySpec_OutputVectorSpec& operator=(const ExampleQuerySpec_OutputVectorSpec& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline ExampleQuerySpec_OutputVectorSpec& operator=(ExampleQuerySpec_OutputVectorSpec&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ExampleQuerySpec_OutputVectorSpec& default_instance() {
    return *internal_default_instance();
  }
  static inline const ExampleQuerySpec_OutputVectorSpec* internal_default_instance() {
    return reinterpret_cast<const ExampleQuerySpec_OutputVectorSpec*>(
               &_ExampleQuerySpec_OutputVectorSpec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    24;

  friend void swap(ExampleQuerySpec_OutputVectorSpec& a, ExampleQuerySpec_OutputVectorSpec& b) {
    a.Swap(&b);
  }
  inline void Swap(ExampleQuerySpec_OutputVectorSpec* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ExampleQuerySpec_OutputVectorSpec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ExampleQuerySpec_OutputVectorSpec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ExampleQuerySpec_OutputVectorSpec>(arena);
  }
  ExampleQuerySpec_OutputVectorSpec* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const ExampleQuerySpec_OutputVectorSpec& from);
  void MergeFrom(const ExampleQuerySpec_OutputVectorSpec& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ExampleQuerySpec_OutputVectorSpec* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.ExampleQuerySpec.OutputVectorSpec";
  }
  protected:
  explicit ExampleQuerySpec_OutputVectorSpec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

  typedef ExampleQuerySpec_OutputVectorSpec_DataType DataType;
  static constexpr DataType UNSPECIFIED =
    ExampleQuerySpec_OutputVectorSpec_DataType_UNSPECIFIED;
  static constexpr DataType INT32 =
    ExampleQuerySpec_OutputVectorSpec_DataType_INT32;
  static constexpr DataType INT64 =
    ExampleQuerySpec_OutputVectorSpec_DataType_INT64;
  static constexpr DataType BOOL =
    ExampleQuerySpec_OutputVectorSpec_DataType_BOOL;
  static constexpr DataType FLOAT =
    ExampleQuerySpec_OutputVectorSpec_DataType_FLOAT;
  static constexpr DataType DOUBLE =
    ExampleQuerySpec_OutputVectorSpec_DataType_DOUBLE;
  static constexpr DataType BYTES =
    ExampleQuerySpec_OutputVectorSpec_DataType_BYTES;
  static constexpr DataType STRING =
    ExampleQuerySpec_OutputVectorSpec_DataType_STRING;
  static inline bool DataType_IsValid(int value) {
    return ExampleQuerySpec_OutputVectorSpec_DataType_IsValid(value);
  }
  static constexpr DataType DataType_MIN =
    ExampleQuerySpec_OutputVectorSpec_DataType_DataType_MIN;
  static constexpr DataType DataType_MAX =
    ExampleQuerySpec_OutputVectorSpec_DataType_DataType_MAX;
  static constexpr int DataType_ARRAYSIZE =
    ExampleQuerySpec_OutputVectorSpec_DataType_DataType_ARRAYSIZE;
  template<typename T>
  static inline const std::string& DataType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, DataType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function DataType_Name.");
    return ExampleQuerySpec_OutputVectorSpec_DataType_Name(enum_t_value);
  }
  static inline bool DataType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      DataType* value) {
    return ExampleQuerySpec_OutputVectorSpec_DataType_Parse(name, value);
  }

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

  enum : int {
    kVectorNameFieldNumber = 1,
    kDataTypeFieldNumber = 2,
  };
  // string vector_name = 1;
  void clear_vector_name();
  const std::string& vector_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_vector_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_vector_name();
  PROTOBUF_NODISCARD std::string* release_vector_name();
  void set_allocated_vector_name(std::string* vector_name);
  private:
  const std::string& _internal_vector_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_vector_name(const std::string& value);
  std::string* _internal_mutable_vector_name();
  public:

  // .google.internal.federated.plan.ExampleQuerySpec.OutputVectorSpec.DataType data_type = 2;
  void clear_data_type();
  ::google::internal::federated::plan::ExampleQuerySpec_OutputVectorSpec_DataType data_type() const;
  void set_data_type(::google::internal::federated::plan::ExampleQuerySpec_OutputVectorSpec_DataType value);
  private:
  ::google::internal::federated::plan::ExampleQuerySpec_OutputVectorSpec_DataType _internal_data_type() const;
  void _internal_set_data_type(::google::internal::federated::plan::ExampleQuerySpec_OutputVectorSpec_DataType value);
  public:

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.ExampleQuerySpec.OutputVectorSpec)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr vector_name_;
    int data_type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class ExampleQuerySpec_ExampleQuery_OutputVectorSpecsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<ExampleQuerySpec_ExampleQuery_OutputVectorSpecsEntry_DoNotUse,
    std::string, ::google::internal::federated::plan::ExampleQuerySpec_OutputVectorSpec,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<ExampleQuerySpec_ExampleQuery_OutputVectorSpecsEntry_DoNotUse,
    std::string, ::google::internal::federated::plan::ExampleQuerySpec_OutputVectorSpec,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  ExampleQuerySpec_ExampleQuery_OutputVectorSpecsEntry_DoNotUse();
  explicit PROTOBUF_CONSTEXPR ExampleQuerySpec_ExampleQuery_OutputVectorSpecsEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit ExampleQuerySpec_ExampleQuery_OutputVectorSpecsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const ExampleQuerySpec_ExampleQuery_OutputVectorSpecsEntry_DoNotUse& other);
  static const ExampleQuerySpec_ExampleQuery_OutputVectorSpecsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const ExampleQuerySpec_ExampleQuery_OutputVectorSpecsEntry_DoNotUse*>(&_ExampleQuerySpec_ExampleQuery_OutputVectorSpecsEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "google.internal.federated.plan.ExampleQuerySpec.ExampleQuery.OutputVectorSpecsEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};

// -------------------------------------------------------------------

class ExampleQuerySpec_ExampleQuery final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.ExampleQuerySpec.ExampleQuery) */ {
 public:
  inline ExampleQuerySpec_ExampleQuery() : ExampleQuerySpec_ExampleQuery(nullptr) {}
  ~ExampleQuerySpec_ExampleQuery() override;
  explicit PROTOBUF_CONSTEXPR ExampleQuerySpec_ExampleQuery(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ExampleQuerySpec_ExampleQuery(const ExampleQuerySpec_ExampleQuery& from);
  ExampleQuerySpec_ExampleQuery(ExampleQuerySpec_ExampleQuery&& from) noexcept
    : ExampleQuerySpec_ExampleQuery() {
    *this = ::std::move(from);
  }

  inline ExampleQuerySpec_ExampleQuery& operator=(const ExampleQuerySpec_ExampleQuery& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline ExampleQuerySpec_ExampleQuery& operator=(ExampleQuerySpec_ExampleQuery&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ExampleQuerySpec_ExampleQuery& default_instance() {
    return *internal_default_instance();
  }
  static inline const ExampleQuerySpec_ExampleQuery* internal_default_instance() {
    return reinterpret_cast<const ExampleQuerySpec_ExampleQuery*>(
               &_ExampleQuerySpec_ExampleQuery_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    26;

  friend void swap(ExampleQuerySpec_ExampleQuery& a, ExampleQuerySpec_ExampleQuery& b) {
    a.Swap(&b);
  }
  inline void Swap(ExampleQuerySpec_ExampleQuery* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ExampleQuerySpec_ExampleQuery* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ExampleQuerySpec_ExampleQuery* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ExampleQuerySpec_ExampleQuery>(arena);
  }
  ExampleQuerySpec_ExampleQuery* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const ExampleQuerySpec_ExampleQuery& from);
  void MergeFrom(const ExampleQuerySpec_ExampleQuery& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ExampleQuerySpec_ExampleQuery* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.ExampleQuerySpec.ExampleQuery";
  }
  protected:
  explicit ExampleQuerySpec_ExampleQuery(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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


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

  enum : int {
    kOutputVectorSpecsFieldNumber = 2,
    kExampleSelectorFieldNumber = 1,
  };
  // map<string, .google.internal.federated.plan.ExampleQuerySpec.OutputVectorSpec> output_vector_specs = 2;
  int output_vector_specs_size() const;
  private:
  int _internal_output_vector_specs_size() const;
  public:
  void clear_output_vector_specs();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::ExampleQuerySpec_OutputVectorSpec >&
      _internal_output_vector_specs() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::ExampleQuerySpec_OutputVectorSpec >*
      _internal_mutable_output_vector_specs();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::ExampleQuerySpec_OutputVectorSpec >&
      output_vector_specs() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::ExampleQuerySpec_OutputVectorSpec >*
      mutable_output_vector_specs();

  // .google.internal.federated.plan.ExampleSelector example_selector = 1;
  bool has_example_selector() const;
  private:
  bool _internal_has_example_selector() const;
  public:
  void clear_example_selector();
  const ::google::internal::federated::plan::ExampleSelector& example_selector() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::ExampleSelector* release_example_selector();
  ::google::internal::federated::plan::ExampleSelector* mutable_example_selector();
  void set_allocated_example_selector(::google::internal::federated::plan::ExampleSelector* example_selector);
  private:
  const ::google::internal::federated::plan::ExampleSelector& _internal_example_selector() const;
  ::google::internal::federated::plan::ExampleSelector* _internal_mutable_example_selector();
  public:
  void unsafe_arena_set_allocated_example_selector(
      ::google::internal::federated::plan::ExampleSelector* example_selector);
  ::google::internal::federated::plan::ExampleSelector* unsafe_arena_release_example_selector();

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.ExampleQuerySpec.ExampleQuery)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::MapFieldLite<
        ExampleQuerySpec_ExampleQuery_OutputVectorSpecsEntry_DoNotUse,
        std::string, ::google::internal::federated::plan::ExampleQuerySpec_OutputVectorSpec,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> output_vector_specs_;
    ::google::internal::federated::plan::ExampleSelector* example_selector_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class ExampleQuerySpec final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.ExampleQuerySpec) */ {
 public:
  inline ExampleQuerySpec() : ExampleQuerySpec(nullptr) {}
  ~ExampleQuerySpec() override;
  explicit PROTOBUF_CONSTEXPR ExampleQuerySpec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ExampleQuerySpec(const ExampleQuerySpec& from);
  ExampleQuerySpec(ExampleQuerySpec&& from) noexcept
    : ExampleQuerySpec() {
    *this = ::std::move(from);
  }

  inline ExampleQuerySpec& operator=(const ExampleQuerySpec& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline ExampleQuerySpec& operator=(ExampleQuerySpec&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ExampleQuerySpec& default_instance() {
    return *internal_default_instance();
  }
  static inline const ExampleQuerySpec* internal_default_instance() {
    return reinterpret_cast<const ExampleQuerySpec*>(
               &_ExampleQuerySpec_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    27;

  friend void swap(ExampleQuerySpec& a, ExampleQuerySpec& b) {
    a.Swap(&b);
  }
  inline void Swap(ExampleQuerySpec* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ExampleQuerySpec* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ExampleQuerySpec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ExampleQuerySpec>(arena);
  }
  ExampleQuerySpec* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const ExampleQuerySpec& from);
  void MergeFrom(const ExampleQuerySpec& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ExampleQuerySpec* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.ExampleQuerySpec";
  }
  protected:
  explicit ExampleQuerySpec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

  typedef ExampleQuerySpec_OutputVectorSpec OutputVectorSpec;
  typedef ExampleQuerySpec_ExampleQuery ExampleQuery;

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

  enum : int {
    kExampleQueriesFieldNumber = 1,
  };
  // repeated .google.internal.federated.plan.ExampleQuerySpec.ExampleQuery example_queries = 1;
  int example_queries_size() const;
  private:
  int _internal_example_queries_size() const;
  public:
  void clear_example_queries();
  ::google::internal::federated::plan::ExampleQuerySpec_ExampleQuery* mutable_example_queries(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::ExampleQuerySpec_ExampleQuery >*
      mutable_example_queries();
  private:
  const ::google::internal::federated::plan::ExampleQuerySpec_ExampleQuery& _internal_example_queries(int index) const;
  ::google::internal::federated::plan::ExampleQuerySpec_ExampleQuery* _internal_add_example_queries();
  public:
  const ::google::internal::federated::plan::ExampleQuerySpec_ExampleQuery& example_queries(int index) const;
  ::google::internal::federated::plan::ExampleQuerySpec_ExampleQuery* add_example_queries();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::ExampleQuerySpec_ExampleQuery >&
      example_queries() const;

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.ExampleQuerySpec)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::ExampleQuerySpec_ExampleQuery > example_queries_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class FederatedComputeIORouter_AggregationsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<FederatedComputeIORouter_AggregationsEntry_DoNotUse,
    std::string, ::google::internal::federated::plan::AggregationConfig,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<FederatedComputeIORouter_AggregationsEntry_DoNotUse,
    std::string, ::google::internal::federated::plan::AggregationConfig,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  FederatedComputeIORouter_AggregationsEntry_DoNotUse();
  explicit PROTOBUF_CONSTEXPR FederatedComputeIORouter_AggregationsEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit FederatedComputeIORouter_AggregationsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const FederatedComputeIORouter_AggregationsEntry_DoNotUse& other);
  static const FederatedComputeIORouter_AggregationsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const FederatedComputeIORouter_AggregationsEntry_DoNotUse*>(&_FederatedComputeIORouter_AggregationsEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "google.internal.federated.plan.FederatedComputeIORouter.AggregationsEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};

// -------------------------------------------------------------------

class FederatedComputeIORouter final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.FederatedComputeIORouter) */ {
 public:
  inline FederatedComputeIORouter() : FederatedComputeIORouter(nullptr) {}
  ~FederatedComputeIORouter() override;
  explicit PROTOBUF_CONSTEXPR FederatedComputeIORouter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  FederatedComputeIORouter(const FederatedComputeIORouter& from);
  FederatedComputeIORouter(FederatedComputeIORouter&& from) noexcept
    : FederatedComputeIORouter() {
    *this = ::std::move(from);
  }

  inline FederatedComputeIORouter& operator=(const FederatedComputeIORouter& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline FederatedComputeIORouter& operator=(FederatedComputeIORouter&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const FederatedComputeIORouter& default_instance() {
    return *internal_default_instance();
  }
  static inline const FederatedComputeIORouter* internal_default_instance() {
    return reinterpret_cast<const FederatedComputeIORouter*>(
               &_FederatedComputeIORouter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    29;

  friend void swap(FederatedComputeIORouter& a, FederatedComputeIORouter& b) {
    a.Swap(&b);
  }
  inline void Swap(FederatedComputeIORouter* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FederatedComputeIORouter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  FederatedComputeIORouter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<FederatedComputeIORouter>(arena);
  }
  FederatedComputeIORouter* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const FederatedComputeIORouter& from);
  void MergeFrom(const FederatedComputeIORouter& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(FederatedComputeIORouter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.FederatedComputeIORouter";
  }
  protected:
  explicit FederatedComputeIORouter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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


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

  enum : int {
    kAggregationsFieldNumber = 3,
    kInputFilepathTensorNameFieldNumber = 1,
    kOutputFilepathTensorNameFieldNumber = 2,
  };
  // map<string, .google.internal.federated.plan.AggregationConfig> aggregations = 3;
  int aggregations_size() const;
  private:
  int _internal_aggregations_size() const;
  public:
  void clear_aggregations();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::AggregationConfig >&
      _internal_aggregations() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::AggregationConfig >*
      _internal_mutable_aggregations();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::AggregationConfig >&
      aggregations() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::AggregationConfig >*
      mutable_aggregations();

  // string input_filepath_tensor_name = 1;
  void clear_input_filepath_tensor_name();
  const std::string& input_filepath_tensor_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_input_filepath_tensor_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_input_filepath_tensor_name();
  PROTOBUF_NODISCARD std::string* release_input_filepath_tensor_name();
  void set_allocated_input_filepath_tensor_name(std::string* input_filepath_tensor_name);
  private:
  const std::string& _internal_input_filepath_tensor_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_input_filepath_tensor_name(const std::string& value);
  std::string* _internal_mutable_input_filepath_tensor_name();
  public:

  // string output_filepath_tensor_name = 2;
  void clear_output_filepath_tensor_name();
  const std::string& output_filepath_tensor_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_output_filepath_tensor_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_output_filepath_tensor_name();
  PROTOBUF_NODISCARD std::string* release_output_filepath_tensor_name();
  void set_allocated_output_filepath_tensor_name(std::string* output_filepath_tensor_name);
  private:
  const std::string& _internal_output_filepath_tensor_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_output_filepath_tensor_name(const std::string& value);
  std::string* _internal_mutable_output_filepath_tensor_name();
  public:

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.FederatedComputeIORouter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::MapFieldLite<
        FederatedComputeIORouter_AggregationsEntry_DoNotUse,
        std::string, ::google::internal::federated::plan::AggregationConfig,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> aggregations_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr input_filepath_tensor_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr output_filepath_tensor_name_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class FederatedExampleQueryIORouter_AggregationsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<FederatedExampleQueryIORouter_AggregationsEntry_DoNotUse,
    std::string, ::google::internal::federated::plan::AggregationConfig,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<FederatedExampleQueryIORouter_AggregationsEntry_DoNotUse,
    std::string, ::google::internal::federated::plan::AggregationConfig,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  FederatedExampleQueryIORouter_AggregationsEntry_DoNotUse();
  explicit PROTOBUF_CONSTEXPR FederatedExampleQueryIORouter_AggregationsEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit FederatedExampleQueryIORouter_AggregationsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const FederatedExampleQueryIORouter_AggregationsEntry_DoNotUse& other);
  static const FederatedExampleQueryIORouter_AggregationsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const FederatedExampleQueryIORouter_AggregationsEntry_DoNotUse*>(&_FederatedExampleQueryIORouter_AggregationsEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "google.internal.federated.plan.FederatedExampleQueryIORouter.AggregationsEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};

// -------------------------------------------------------------------

class FederatedExampleQueryIORouter final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.FederatedExampleQueryIORouter) */ {
 public:
  inline FederatedExampleQueryIORouter() : FederatedExampleQueryIORouter(nullptr) {}
  ~FederatedExampleQueryIORouter() override;
  explicit PROTOBUF_CONSTEXPR FederatedExampleQueryIORouter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  FederatedExampleQueryIORouter(const FederatedExampleQueryIORouter& from);
  FederatedExampleQueryIORouter(FederatedExampleQueryIORouter&& from) noexcept
    : FederatedExampleQueryIORouter() {
    *this = ::std::move(from);
  }

  inline FederatedExampleQueryIORouter& operator=(const FederatedExampleQueryIORouter& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline FederatedExampleQueryIORouter& operator=(FederatedExampleQueryIORouter&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const FederatedExampleQueryIORouter& default_instance() {
    return *internal_default_instance();
  }
  static inline const FederatedExampleQueryIORouter* internal_default_instance() {
    return reinterpret_cast<const FederatedExampleQueryIORouter*>(
               &_FederatedExampleQueryIORouter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    31;

  friend void swap(FederatedExampleQueryIORouter& a, FederatedExampleQueryIORouter& b) {
    a.Swap(&b);
  }
  inline void Swap(FederatedExampleQueryIORouter* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FederatedExampleQueryIORouter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  FederatedExampleQueryIORouter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<FederatedExampleQueryIORouter>(arena);
  }
  FederatedExampleQueryIORouter* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const FederatedExampleQueryIORouter& from);
  void MergeFrom(const FederatedExampleQueryIORouter& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(FederatedExampleQueryIORouter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.FederatedExampleQueryIORouter";
  }
  protected:
  explicit FederatedExampleQueryIORouter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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


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

  enum : int {
    kAggregationsFieldNumber = 1,
  };
  // map<string, .google.internal.federated.plan.AggregationConfig> aggregations = 1;
  int aggregations_size() const;
  private:
  int _internal_aggregations_size() const;
  public:
  void clear_aggregations();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::AggregationConfig >&
      _internal_aggregations() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::AggregationConfig >*
      _internal_mutable_aggregations();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::AggregationConfig >&
      aggregations() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::AggregationConfig >*
      mutable_aggregations();

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.FederatedExampleQueryIORouter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::MapFieldLite<
        FederatedExampleQueryIORouter_AggregationsEntry_DoNotUse,
        std::string, ::google::internal::federated::plan::AggregationConfig,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> aggregations_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class AggregationConfig final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.AggregationConfig) */ {
 public:
  inline AggregationConfig() : AggregationConfig(nullptr) {}
  ~AggregationConfig() override;
  explicit PROTOBUF_CONSTEXPR AggregationConfig(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  AggregationConfig(const AggregationConfig& from);
  AggregationConfig(AggregationConfig&& from) noexcept
    : AggregationConfig() {
    *this = ::std::move(from);
  }

  inline AggregationConfig& operator=(const AggregationConfig& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline AggregationConfig& operator=(AggregationConfig&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const AggregationConfig& default_instance() {
    return *internal_default_instance();
  }
  enum ProtocolConfigCase {
    kSecureAggregation = 2,
    kTfV1CheckpointAggregation = 3,
    PROTOCOL_CONFIG_NOT_SET = 0,
  };

  static inline const AggregationConfig* internal_default_instance() {
    return reinterpret_cast<const AggregationConfig*>(
               &_AggregationConfig_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    32;

  friend void swap(AggregationConfig& a, AggregationConfig& b) {
    a.Swap(&b);
  }
  inline void Swap(AggregationConfig* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AggregationConfig* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  AggregationConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AggregationConfig>(arena);
  }
  AggregationConfig* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const AggregationConfig& from);
  void MergeFrom(const AggregationConfig& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(AggregationConfig* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.AggregationConfig";
  }
  protected:
  explicit AggregationConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kSecureAggregationFieldNumber = 2,
    kTfV1CheckpointAggregationFieldNumber = 3,
  };
  // .google.internal.federated.plan.SecureAggregationConfig secure_aggregation = 2;
  bool has_secure_aggregation() const;
  private:
  bool _internal_has_secure_aggregation() const;
  public:
  void clear_secure_aggregation();
  const ::google::internal::federated::plan::SecureAggregationConfig& secure_aggregation() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::SecureAggregationConfig* release_secure_aggregation();
  ::google::internal::federated::plan::SecureAggregationConfig* mutable_secure_aggregation();
  void set_allocated_secure_aggregation(::google::internal::federated::plan::SecureAggregationConfig* secure_aggregation);
  private:
  const ::google::internal::federated::plan::SecureAggregationConfig& _internal_secure_aggregation() const;
  ::google::internal::federated::plan::SecureAggregationConfig* _internal_mutable_secure_aggregation();
  public:
  void unsafe_arena_set_allocated_secure_aggregation(
      ::google::internal::federated::plan::SecureAggregationConfig* secure_aggregation);
  ::google::internal::federated::plan::SecureAggregationConfig* unsafe_arena_release_secure_aggregation();

  // .google.internal.federated.plan.TFV1CheckpointAggregation tf_v1_checkpoint_aggregation = 3;
  bool has_tf_v1_checkpoint_aggregation() const;
  private:
  bool _internal_has_tf_v1_checkpoint_aggregation() const;
  public:
  void clear_tf_v1_checkpoint_aggregation();
  const ::google::internal::federated::plan::TFV1CheckpointAggregation& tf_v1_checkpoint_aggregation() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::TFV1CheckpointAggregation* release_tf_v1_checkpoint_aggregation();
  ::google::internal::federated::plan::TFV1CheckpointAggregation* mutable_tf_v1_checkpoint_aggregation();
  void set_allocated_tf_v1_checkpoint_aggregation(::google::internal::federated::plan::TFV1CheckpointAggregation* tf_v1_checkpoint_aggregation);
  private:
  const ::google::internal::federated::plan::TFV1CheckpointAggregation& _internal_tf_v1_checkpoint_aggregation() const;
  ::google::internal::federated::plan::TFV1CheckpointAggregation* _internal_mutable_tf_v1_checkpoint_aggregation();
  public:
  void unsafe_arena_set_allocated_tf_v1_checkpoint_aggregation(
      ::google::internal::federated::plan::TFV1CheckpointAggregation* tf_v1_checkpoint_aggregation);
  ::google::internal::federated::plan::TFV1CheckpointAggregation* unsafe_arena_release_tf_v1_checkpoint_aggregation();

  void clear_protocol_config();
  ProtocolConfigCase protocol_config_case() const;
  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.AggregationConfig)
 private:
  class _Internal;
  void set_has_secure_aggregation();
  void set_has_tf_v1_checkpoint_aggregation();

  inline bool has_protocol_config() const;
  inline void clear_has_protocol_config();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union ProtocolConfigUnion {
      constexpr ProtocolConfigUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::google::internal::federated::plan::SecureAggregationConfig* secure_aggregation_;
      ::google::internal::federated::plan::TFV1CheckpointAggregation* tf_v1_checkpoint_aggregation_;
    } protocol_config_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class SecureAggregationConfig final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.SecureAggregationConfig) */ {
 public:
  inline SecureAggregationConfig() : SecureAggregationConfig(nullptr) {}
  ~SecureAggregationConfig() override;
  explicit PROTOBUF_CONSTEXPR SecureAggregationConfig(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SecureAggregationConfig(const SecureAggregationConfig& from);
  SecureAggregationConfig(SecureAggregationConfig&& from) noexcept
    : SecureAggregationConfig() {
    *this = ::std::move(from);
  }

  inline SecureAggregationConfig& operator=(const SecureAggregationConfig& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline SecureAggregationConfig& operator=(SecureAggregationConfig&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const SecureAggregationConfig& default_instance() {
    return *internal_default_instance();
  }
  static inline const SecureAggregationConfig* internal_default_instance() {
    return reinterpret_cast<const SecureAggregationConfig*>(
               &_SecureAggregationConfig_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    33;

  friend void swap(SecureAggregationConfig& a, SecureAggregationConfig& b) {
    a.Swap(&b);
  }
  inline void Swap(SecureAggregationConfig* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SecureAggregationConfig* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SecureAggregationConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SecureAggregationConfig>(arena);
  }
  SecureAggregationConfig* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SecureAggregationConfig& from);
  void MergeFrom(const SecureAggregationConfig& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SecureAggregationConfig* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.SecureAggregationConfig";
  }
  protected:
  explicit SecureAggregationConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.SecureAggregationConfig)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class TFV1CheckpointAggregation final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.TFV1CheckpointAggregation) */ {
 public:
  inline TFV1CheckpointAggregation() : TFV1CheckpointAggregation(nullptr) {}
  ~TFV1CheckpointAggregation() override;
  explicit PROTOBUF_CONSTEXPR TFV1CheckpointAggregation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  TFV1CheckpointAggregation(const TFV1CheckpointAggregation& from);
  TFV1CheckpointAggregation(TFV1CheckpointAggregation&& from) noexcept
    : TFV1CheckpointAggregation() {
    *this = ::std::move(from);
  }

  inline TFV1CheckpointAggregation& operator=(const TFV1CheckpointAggregation& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline TFV1CheckpointAggregation& operator=(TFV1CheckpointAggregation&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const TFV1CheckpointAggregation& default_instance() {
    return *internal_default_instance();
  }
  static inline const TFV1CheckpointAggregation* internal_default_instance() {
    return reinterpret_cast<const TFV1CheckpointAggregation*>(
               &_TFV1CheckpointAggregation_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    34;

  friend void swap(TFV1CheckpointAggregation& a, TFV1CheckpointAggregation& b) {
    a.Swap(&b);
  }
  inline void Swap(TFV1CheckpointAggregation* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TFV1CheckpointAggregation* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  TFV1CheckpointAggregation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TFV1CheckpointAggregation>(arena);
  }
  TFV1CheckpointAggregation* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const TFV1CheckpointAggregation& from);
  void MergeFrom(const TFV1CheckpointAggregation& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(TFV1CheckpointAggregation* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.TFV1CheckpointAggregation";
  }
  protected:
  explicit TFV1CheckpointAggregation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.TFV1CheckpointAggregation)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class FederatedComputeEligibilityIORouter final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.FederatedComputeEligibilityIORouter) */ {
 public:
  inline FederatedComputeEligibilityIORouter() : FederatedComputeEligibilityIORouter(nullptr) {}
  ~FederatedComputeEligibilityIORouter() override;
  explicit PROTOBUF_CONSTEXPR FederatedComputeEligibilityIORouter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  FederatedComputeEligibilityIORouter(const FederatedComputeEligibilityIORouter& from);
  FederatedComputeEligibilityIORouter(FederatedComputeEligibilityIORouter&& from) noexcept
    : FederatedComputeEligibilityIORouter() {
    *this = ::std::move(from);
  }

  inline FederatedComputeEligibilityIORouter& operator=(const FederatedComputeEligibilityIORouter& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline FederatedComputeEligibilityIORouter& operator=(FederatedComputeEligibilityIORouter&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const FederatedComputeEligibilityIORouter& default_instance() {
    return *internal_default_instance();
  }
  static inline const FederatedComputeEligibilityIORouter* internal_default_instance() {
    return reinterpret_cast<const FederatedComputeEligibilityIORouter*>(
               &_FederatedComputeEligibilityIORouter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    35;

  friend void swap(FederatedComputeEligibilityIORouter& a, FederatedComputeEligibilityIORouter& b) {
    a.Swap(&b);
  }
  inline void Swap(FederatedComputeEligibilityIORouter* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FederatedComputeEligibilityIORouter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  FederatedComputeEligibilityIORouter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<FederatedComputeEligibilityIORouter>(arena);
  }
  FederatedComputeEligibilityIORouter* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const FederatedComputeEligibilityIORouter& from);
  void MergeFrom(const FederatedComputeEligibilityIORouter& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(FederatedComputeEligibilityIORouter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.FederatedComputeEligibilityIORouter";
  }
  protected:
  explicit FederatedComputeEligibilityIORouter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kInputFilepathTensorNameFieldNumber = 1,
    kTaskEligibilityInfoTensorNameFieldNumber = 2,
  };
  // string input_filepath_tensor_name = 1;
  void clear_input_filepath_tensor_name();
  const std::string& input_filepath_tensor_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_input_filepath_tensor_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_input_filepath_tensor_name();
  PROTOBUF_NODISCARD std::string* release_input_filepath_tensor_name();
  void set_allocated_input_filepath_tensor_name(std::string* input_filepath_tensor_name);
  private:
  const std::string& _internal_input_filepath_tensor_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_input_filepath_tensor_name(const std::string& value);
  std::string* _internal_mutable_input_filepath_tensor_name();
  public:

  // string task_eligibility_info_tensor_name = 2;
  void clear_task_eligibility_info_tensor_name();
  const std::string& task_eligibility_info_tensor_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_task_eligibility_info_tensor_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_task_eligibility_info_tensor_name();
  PROTOBUF_NODISCARD std::string* release_task_eligibility_info_tensor_name();
  void set_allocated_task_eligibility_info_tensor_name(std::string* task_eligibility_info_tensor_name);
  private:
  const std::string& _internal_task_eligibility_info_tensor_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_task_eligibility_info_tensor_name(const std::string& value);
  std::string* _internal_mutable_task_eligibility_info_tensor_name();
  public:

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.FederatedComputeEligibilityIORouter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr input_filepath_tensor_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr task_eligibility_info_tensor_name_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class LocalComputeIORouter final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.LocalComputeIORouter) */ {
 public:
  inline LocalComputeIORouter() : LocalComputeIORouter(nullptr) {}
  ~LocalComputeIORouter() override;
  explicit PROTOBUF_CONSTEXPR LocalComputeIORouter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  LocalComputeIORouter(const LocalComputeIORouter& from);
  LocalComputeIORouter(LocalComputeIORouter&& from) noexcept
    : LocalComputeIORouter() {
    *this = ::std::move(from);
  }

  inline LocalComputeIORouter& operator=(const LocalComputeIORouter& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline LocalComputeIORouter& operator=(LocalComputeIORouter&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const LocalComputeIORouter& default_instance() {
    return *internal_default_instance();
  }
  enum InputResourceCase {
    kInputDirTensorName = 1,
    kMultipleInputResources = 3,
    INPUT_RESOURCE_NOT_SET = 0,
  };

  static inline const LocalComputeIORouter* internal_default_instance() {
    return reinterpret_cast<const LocalComputeIORouter*>(
               &_LocalComputeIORouter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    36;

  friend void swap(LocalComputeIORouter& a, LocalComputeIORouter& b) {
    a.Swap(&b);
  }
  inline void Swap(LocalComputeIORouter* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LocalComputeIORouter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  LocalComputeIORouter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LocalComputeIORouter>(arena);
  }
  LocalComputeIORouter* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const LocalComputeIORouter& from);
  void MergeFrom(const LocalComputeIORouter& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(LocalComputeIORouter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.LocalComputeIORouter";
  }
  protected:
  explicit LocalComputeIORouter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kOutputDirTensorNameFieldNumber = 2,
    kInputDirTensorNameFieldNumber = 1,
    kMultipleInputResourcesFieldNumber = 3,
  };
  // string output_dir_tensor_name = 2;
  void clear_output_dir_tensor_name();
  const std::string& output_dir_tensor_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_output_dir_tensor_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_output_dir_tensor_name();
  PROTOBUF_NODISCARD std::string* release_output_dir_tensor_name();
  void set_allocated_output_dir_tensor_name(std::string* output_dir_tensor_name);
  private:
  const std::string& _internal_output_dir_tensor_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_output_dir_tensor_name(const std::string& value);
  std::string* _internal_mutable_output_dir_tensor_name();
  public:

  // string input_dir_tensor_name = 1;
  bool has_input_dir_tensor_name() const;
  private:
  bool _internal_has_input_dir_tensor_name() const;
  public:
  void clear_input_dir_tensor_name();
  const std::string& input_dir_tensor_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_input_dir_tensor_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_input_dir_tensor_name();
  PROTOBUF_NODISCARD std::string* release_input_dir_tensor_name();
  void set_allocated_input_dir_tensor_name(std::string* input_dir_tensor_name);
  private:
  const std::string& _internal_input_dir_tensor_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_input_dir_tensor_name(const std::string& value);
  std::string* _internal_mutable_input_dir_tensor_name();
  public:

  // .google.internal.federated.plan.MultipleInputResources multiple_input_resources = 3;
  bool has_multiple_input_resources() const;
  private:
  bool _internal_has_multiple_input_resources() const;
  public:
  void clear_multiple_input_resources();
  const ::google::internal::federated::plan::MultipleInputResources& multiple_input_resources() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::MultipleInputResources* release_multiple_input_resources();
  ::google::internal::federated::plan::MultipleInputResources* mutable_multiple_input_resources();
  void set_allocated_multiple_input_resources(::google::internal::federated::plan::MultipleInputResources* multiple_input_resources);
  private:
  const ::google::internal::federated::plan::MultipleInputResources& _internal_multiple_input_resources() const;
  ::google::internal::federated::plan::MultipleInputResources* _internal_mutable_multiple_input_resources();
  public:
  void unsafe_arena_set_allocated_multiple_input_resources(
      ::google::internal::federated::plan::MultipleInputResources* multiple_input_resources);
  ::google::internal::federated::plan::MultipleInputResources* unsafe_arena_release_multiple_input_resources();

  void clear_input_resource();
  InputResourceCase input_resource_case() const;
  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.LocalComputeIORouter)
 private:
  class _Internal;
  void set_has_input_dir_tensor_name();
  void set_has_multiple_input_resources();

  inline bool has_input_resource() const;
  inline void clear_has_input_resource();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr output_dir_tensor_name_;
    union InputResourceUnion {
      constexpr InputResourceUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr input_dir_tensor_name_;
      ::google::internal::federated::plan::MultipleInputResources* multiple_input_resources_;
    } input_resource_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class MultipleInputResources_InputResourceTensorNameMapEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<MultipleInputResources_InputResourceTensorNameMapEntry_DoNotUse,
    std::string, std::string,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<MultipleInputResources_InputResourceTensorNameMapEntry_DoNotUse,
    std::string, std::string,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> SuperType;
  MultipleInputResources_InputResourceTensorNameMapEntry_DoNotUse();
  explicit PROTOBUF_CONSTEXPR MultipleInputResources_InputResourceTensorNameMapEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit MultipleInputResources_InputResourceTensorNameMapEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const MultipleInputResources_InputResourceTensorNameMapEntry_DoNotUse& other);
  static const MultipleInputResources_InputResourceTensorNameMapEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const MultipleInputResources_InputResourceTensorNameMapEntry_DoNotUse*>(&_MultipleInputResources_InputResourceTensorNameMapEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "google.internal.federated.plan.MultipleInputResources.InputResourceTensorNameMapEntry.key");
 }
  static bool ValidateValue(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "google.internal.federated.plan.MultipleInputResources.InputResourceTensorNameMapEntry.value");
 }
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};

// -------------------------------------------------------------------

class MultipleInputResources final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.MultipleInputResources) */ {
 public:
  inline MultipleInputResources() : MultipleInputResources(nullptr) {}
  ~MultipleInputResources() override;
  explicit PROTOBUF_CONSTEXPR MultipleInputResources(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MultipleInputResources(const MultipleInputResources& from);
  MultipleInputResources(MultipleInputResources&& from) noexcept
    : MultipleInputResources() {
    *this = ::std::move(from);
  }

  inline MultipleInputResources& operator=(const MultipleInputResources& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline MultipleInputResources& operator=(MultipleInputResources&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const MultipleInputResources& default_instance() {
    return *internal_default_instance();
  }
  static inline const MultipleInputResources* internal_default_instance() {
    return reinterpret_cast<const MultipleInputResources*>(
               &_MultipleInputResources_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    38;

  friend void swap(MultipleInputResources& a, MultipleInputResources& b) {
    a.Swap(&b);
  }
  inline void Swap(MultipleInputResources* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MultipleInputResources* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  MultipleInputResources* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<MultipleInputResources>(arena);
  }
  MultipleInputResources* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const MultipleInputResources& from);
  void MergeFrom(const MultipleInputResources& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(MultipleInputResources* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.MultipleInputResources";
  }
  protected:
  explicit MultipleInputResources(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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


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

  enum : int {
    kInputResourceTensorNameMapFieldNumber = 1,
  };
  // map<string, string> input_resource_tensor_name_map = 1;
  int input_resource_tensor_name_map_size() const;
  private:
  int _internal_input_resource_tensor_name_map_size() const;
  public:
  void clear_input_resource_tensor_name_map();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
      _internal_input_resource_tensor_name_map() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
      _internal_mutable_input_resource_tensor_name_map();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
      input_resource_tensor_name_map() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
      mutable_input_resource_tensor_name_map();

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.MultipleInputResources)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::MapFieldLite<
        MultipleInputResources_InputResourceTensorNameMapEntry_DoNotUse,
        std::string, std::string,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> input_resource_tensor_name_map_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class AsyncInputFeed final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.AsyncInputFeed) */ {
 public:
  inline AsyncInputFeed() : AsyncInputFeed(nullptr) {}
  ~AsyncInputFeed() override;
  explicit PROTOBUF_CONSTEXPR AsyncInputFeed(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  AsyncInputFeed(const AsyncInputFeed& from);
  AsyncInputFeed(AsyncInputFeed&& from) noexcept
    : AsyncInputFeed() {
    *this = ::std::move(from);
  }

  inline AsyncInputFeed& operator=(const AsyncInputFeed& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline AsyncInputFeed& operator=(AsyncInputFeed&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const AsyncInputFeed& default_instance() {
    return *internal_default_instance();
  }
  static inline const AsyncInputFeed* internal_default_instance() {
    return reinterpret_cast<const AsyncInputFeed*>(
               &_AsyncInputFeed_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    39;

  friend void swap(AsyncInputFeed& a, AsyncInputFeed& b) {
    a.Swap(&b);
  }
  inline void Swap(AsyncInputFeed* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AsyncInputFeed* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  AsyncInputFeed* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AsyncInputFeed>(arena);
  }
  AsyncInputFeed* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const AsyncInputFeed& from);
  void MergeFrom(const AsyncInputFeed& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(AsyncInputFeed* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.AsyncInputFeed";
  }
  protected:
  explicit AsyncInputFeed(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kEnqueueParamsFieldNumber = 2,
    kEnqueueOpFieldNumber = 1,
    kCloseOpFieldNumber = 3,
    kFeedValuesAreDataFieldNumber = 4,
  };
  // repeated string enqueue_params = 2;
  int enqueue_params_size() const;
  private:
  int _internal_enqueue_params_size() const;
  public:
  void clear_enqueue_params();
  const std::string& enqueue_params(int index) const;
  std::string* mutable_enqueue_params(int index);
  void set_enqueue_params(int index, const std::string& value);
  void set_enqueue_params(int index, std::string&& value);
  void set_enqueue_params(int index, const char* value);
  void set_enqueue_params(int index, const char* value, size_t size);
  std::string* add_enqueue_params();
  void add_enqueue_params(const std::string& value);
  void add_enqueue_params(std::string&& value);
  void add_enqueue_params(const char* value);
  void add_enqueue_params(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& enqueue_params() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_enqueue_params();
  private:
  const std::string& _internal_enqueue_params(int index) const;
  std::string* _internal_add_enqueue_params();
  public:

  // string enqueue_op = 1;
  void clear_enqueue_op();
  const std::string& enqueue_op() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_enqueue_op(ArgT0&& arg0, ArgT... args);
  std::string* mutable_enqueue_op();
  PROTOBUF_NODISCARD std::string* release_enqueue_op();
  void set_allocated_enqueue_op(std::string* enqueue_op);
  private:
  const std::string& _internal_enqueue_op() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_enqueue_op(const std::string& value);
  std::string* _internal_mutable_enqueue_op();
  public:

  // string close_op = 3;
  void clear_close_op();
  const std::string& close_op() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_close_op(ArgT0&& arg0, ArgT... args);
  std::string* mutable_close_op();
  PROTOBUF_NODISCARD std::string* release_close_op();
  void set_allocated_close_op(std::string* close_op);
  private:
  const std::string& _internal_close_op() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_close_op(const std::string& value);
  std::string* _internal_mutable_close_op();
  public:

  // bool feed_values_are_data = 4;
  void clear_feed_values_are_data();
  bool feed_values_are_data() const;
  void set_feed_values_are_data(bool value);
  private:
  bool _internal_feed_values_are_data() const;
  void _internal_set_feed_values_are_data(bool value);
  public:

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.AsyncInputFeed)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> enqueue_params_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr enqueue_op_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr close_op_;
    bool feed_values_are_data_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class DatasetInput final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.DatasetInput) */ {
 public:
  inline DatasetInput() : DatasetInput(nullptr) {}
  ~DatasetInput() override;
  explicit PROTOBUF_CONSTEXPR DatasetInput(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  DatasetInput(const DatasetInput& from);
  DatasetInput(DatasetInput&& from) noexcept
    : DatasetInput() {
    *this = ::std::move(from);
  }

  inline DatasetInput& operator=(const DatasetInput& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline DatasetInput& operator=(DatasetInput&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const DatasetInput& default_instance() {
    return *internal_default_instance();
  }
  static inline const DatasetInput* internal_default_instance() {
    return reinterpret_cast<const DatasetInput*>(
               &_DatasetInput_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    40;

  friend void swap(DatasetInput& a, DatasetInput& b) {
    a.Swap(&b);
  }
  inline void Swap(DatasetInput* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DatasetInput* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  DatasetInput* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DatasetInput>(arena);
  }
  DatasetInput* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const DatasetInput& from);
  void MergeFrom(const DatasetInput& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(DatasetInput* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.DatasetInput";
  }
  protected:
  explicit DatasetInput(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kInitializerFieldNumber = 1,
    kPlaceholdersFieldNumber = 2,
    kBatchSizeFieldNumber = 3,
  };
  // string initializer = 1;
  void clear_initializer();
  const std::string& initializer() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_initializer(ArgT0&& arg0, ArgT... args);
  std::string* mutable_initializer();
  PROTOBUF_NODISCARD std::string* release_initializer();
  void set_allocated_initializer(std::string* initializer);
  private:
  const std::string& _internal_initializer() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_initializer(const std::string& value);
  std::string* _internal_mutable_initializer();
  public:

  // .google.internal.federated.plan.DatasetInputPlaceholders placeholders = 2;
  bool has_placeholders() const;
  private:
  bool _internal_has_placeholders() const;
  public:
  void clear_placeholders();
  const ::google::internal::federated::plan::DatasetInputPlaceholders& placeholders() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::DatasetInputPlaceholders* release_placeholders();
  ::google::internal::federated::plan::DatasetInputPlaceholders* mutable_placeholders();
  void set_allocated_placeholders(::google::internal::federated::plan::DatasetInputPlaceholders* placeholders);
  private:
  const ::google::internal::federated::plan::DatasetInputPlaceholders& _internal_placeholders() const;
  ::google::internal::federated::plan::DatasetInputPlaceholders* _internal_mutable_placeholders();
  public:
  void unsafe_arena_set_allocated_placeholders(
      ::google::internal::federated::plan::DatasetInputPlaceholders* placeholders);
  ::google::internal::federated::plan::DatasetInputPlaceholders* unsafe_arena_release_placeholders();

  // int32 batch_size = 3;
  void clear_batch_size();
  ::int32_t batch_size() const;
  void set_batch_size(::int32_t value);
  private:
  ::int32_t _internal_batch_size() const;
  void _internal_set_batch_size(::int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.DatasetInput)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr initializer_;
    ::google::internal::federated::plan::DatasetInputPlaceholders* placeholders_;
    ::int32_t batch_size_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class DatasetInputPlaceholders final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.DatasetInputPlaceholders) */ {
 public:
  inline DatasetInputPlaceholders() : DatasetInputPlaceholders(nullptr) {}
  ~DatasetInputPlaceholders() override;
  explicit PROTOBUF_CONSTEXPR DatasetInputPlaceholders(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  DatasetInputPlaceholders(const DatasetInputPlaceholders& from);
  DatasetInputPlaceholders(DatasetInputPlaceholders&& from) noexcept
    : DatasetInputPlaceholders() {
    *this = ::std::move(from);
  }

  inline DatasetInputPlaceholders& operator=(const DatasetInputPlaceholders& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline DatasetInputPlaceholders& operator=(DatasetInputPlaceholders&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const DatasetInputPlaceholders& default_instance() {
    return *internal_default_instance();
  }
  static inline const DatasetInputPlaceholders* internal_default_instance() {
    return reinterpret_cast<const DatasetInputPlaceholders*>(
               &_DatasetInputPlaceholders_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    41;

  friend void swap(DatasetInputPlaceholders& a, DatasetInputPlaceholders& b) {
    a.Swap(&b);
  }
  inline void Swap(DatasetInputPlaceholders* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DatasetInputPlaceholders* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  DatasetInputPlaceholders* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DatasetInputPlaceholders>(arena);
  }
  DatasetInputPlaceholders* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const DatasetInputPlaceholders& from);
  void MergeFrom(const DatasetInputPlaceholders& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(DatasetInputPlaceholders* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.DatasetInputPlaceholders";
  }
  protected:
  explicit DatasetInputPlaceholders(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kFilenameFieldNumber = 1,
    kKeyPrefixFieldNumber = 2,
    kNumEpochsFieldNumber = 3,
    kBatchSizeFieldNumber = 4,
  };
  // string filename = 1;
  void clear_filename();
  const std::string& filename() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_filename(ArgT0&& arg0, ArgT... args);
  std::string* mutable_filename();
  PROTOBUF_NODISCARD std::string* release_filename();
  void set_allocated_filename(std::string* filename);
  private:
  const std::string& _internal_filename() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_filename(const std::string& value);
  std::string* _internal_mutable_filename();
  public:

  // string key_prefix = 2;
  void clear_key_prefix();
  const std::string& key_prefix() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_key_prefix(ArgT0&& arg0, ArgT... args);
  std::string* mutable_key_prefix();
  PROTOBUF_NODISCARD std::string* release_key_prefix();
  void set_allocated_key_prefix(std::string* key_prefix);
  private:
  const std::string& _internal_key_prefix() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key_prefix(const std::string& value);
  std::string* _internal_mutable_key_prefix();
  public:

  // string num_epochs = 3;
  void clear_num_epochs();
  const std::string& num_epochs() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_num_epochs(ArgT0&& arg0, ArgT... args);
  std::string* mutable_num_epochs();
  PROTOBUF_NODISCARD std::string* release_num_epochs();
  void set_allocated_num_epochs(std::string* num_epochs);
  private:
  const std::string& _internal_num_epochs() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_num_epochs(const std::string& value);
  std::string* _internal_mutable_num_epochs();
  public:

  // string batch_size = 4;
  void clear_batch_size();
  const std::string& batch_size() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_batch_size(ArgT0&& arg0, ArgT... args);
  std::string* mutable_batch_size();
  PROTOBUF_NODISCARD std::string* release_batch_size();
  void set_allocated_batch_size(std::string* batch_size);
  private:
  const std::string& _internal_batch_size() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_batch_size(const std::string& value);
  std::string* _internal_mutable_batch_size();
  public:

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.DatasetInputPlaceholders)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filename_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_prefix_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr num_epochs_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr batch_size_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class ExampleSelector final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.ExampleSelector) */ {
 public:
  inline ExampleSelector() : ExampleSelector(nullptr) {}
  ~ExampleSelector() override;
  explicit PROTOBUF_CONSTEXPR ExampleSelector(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ExampleSelector(const ExampleSelector& from);
  ExampleSelector(ExampleSelector&& from) noexcept
    : ExampleSelector() {
    *this = ::std::move(from);
  }

  inline ExampleSelector& operator=(const ExampleSelector& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline ExampleSelector& operator=(ExampleSelector&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ExampleSelector& default_instance() {
    return *internal_default_instance();
  }
  static inline const ExampleSelector* internal_default_instance() {
    return reinterpret_cast<const ExampleSelector*>(
               &_ExampleSelector_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    42;

  friend void swap(ExampleSelector& a, ExampleSelector& b) {
    a.Swap(&b);
  }
  inline void Swap(ExampleSelector* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ExampleSelector* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ExampleSelector* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ExampleSelector>(arena);
  }
  ExampleSelector* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const ExampleSelector& from);
  void MergeFrom(const ExampleSelector& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ExampleSelector* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.ExampleSelector";
  }
  protected:
  explicit ExampleSelector(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kCollectionUriFieldNumber = 2,
    kCriteriaFieldNumber = 1,
    kResumptionTokenFieldNumber = 3,
  };
  // string collection_uri = 2;
  void clear_collection_uri();
  const std::string& collection_uri() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_collection_uri(ArgT0&& arg0, ArgT... args);
  std::string* mutable_collection_uri();
  PROTOBUF_NODISCARD std::string* release_collection_uri();
  void set_allocated_collection_uri(std::string* collection_uri);
  private:
  const std::string& _internal_collection_uri() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_collection_uri(const std::string& value);
  std::string* _internal_mutable_collection_uri();
  public:

  // .google.protobuf.Any criteria = 1;
  bool has_criteria() const;
  private:
  bool _internal_has_criteria() const;
  public:
  void clear_criteria();
  const ::PROTOBUF_NAMESPACE_ID::Any& criteria() const;
  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_criteria();
  ::PROTOBUF_NAMESPACE_ID::Any* mutable_criteria();
  void set_allocated_criteria(::PROTOBUF_NAMESPACE_ID::Any* criteria);
  private:
  const ::PROTOBUF_NAMESPACE_ID::Any& _internal_criteria() const;
  ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_criteria();
  public:
  void unsafe_arena_set_allocated_criteria(
      ::PROTOBUF_NAMESPACE_ID::Any* criteria);
  ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_criteria();

  // .google.protobuf.Any resumption_token = 3;
  bool has_resumption_token() const;
  private:
  bool _internal_has_resumption_token() const;
  public:
  void clear_resumption_token();
  const ::PROTOBUF_NAMESPACE_ID::Any& resumption_token() const;
  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_resumption_token();
  ::PROTOBUF_NAMESPACE_ID::Any* mutable_resumption_token();
  void set_allocated_resumption_token(::PROTOBUF_NAMESPACE_ID::Any* resumption_token);
  private:
  const ::PROTOBUF_NAMESPACE_ID::Any& _internal_resumption_token() const;
  ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_resumption_token();
  public:
  void unsafe_arena_set_allocated_resumption_token(
      ::PROTOBUF_NAMESPACE_ID::Any* resumption_token);
  ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_resumption_token();

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.ExampleSelector)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_uri_;
    ::PROTOBUF_NAMESPACE_ID::Any* criteria_;
    ::PROTOBUF_NAMESPACE_ID::Any* resumption_token_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class SlicesSelector final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.SlicesSelector) */ {
 public:
  inline SlicesSelector() : SlicesSelector(nullptr) {}
  ~SlicesSelector() override;
  explicit PROTOBUF_CONSTEXPR SlicesSelector(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SlicesSelector(const SlicesSelector& from);
  SlicesSelector(SlicesSelector&& from) noexcept
    : SlicesSelector() {
    *this = ::std::move(from);
  }

  inline SlicesSelector& operator=(const SlicesSelector& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline SlicesSelector& operator=(SlicesSelector&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const SlicesSelector& default_instance() {
    return *internal_default_instance();
  }
  static inline const SlicesSelector* internal_default_instance() {
    return reinterpret_cast<const SlicesSelector*>(
               &_SlicesSelector_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    43;

  friend void swap(SlicesSelector& a, SlicesSelector& b) {
    a.Swap(&b);
  }
  inline void Swap(SlicesSelector* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SlicesSelector* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SlicesSelector* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SlicesSelector>(arena);
  }
  SlicesSelector* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SlicesSelector& from);
  void MergeFrom(const SlicesSelector& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SlicesSelector* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.SlicesSelector";
  }
  protected:
  explicit SlicesSelector(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kKeysFieldNumber = 2,
    kServedAtIdFieldNumber = 1,
  };
  // repeated int32 keys = 2;
  int keys_size() const;
  private:
  int _internal_keys_size() const;
  public:
  void clear_keys();
  private:
  ::int32_t _internal_keys(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int32_t >&
      _internal_keys() const;
  void _internal_add_keys(::int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int32_t >*
      _internal_mutable_keys();
  public:
  ::int32_t keys(int index) const;
  void set_keys(int index, ::int32_t value);
  void add_keys(::int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int32_t >&
      keys() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int32_t >*
      mutable_keys();

  // string served_at_id = 1;
  void clear_served_at_id();
  const std::string& served_at_id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_served_at_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_served_at_id();
  PROTOBUF_NODISCARD std::string* release_served_at_id();
  void set_allocated_served_at_id(std::string* served_at_id);
  private:
  const std::string& _internal_served_at_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_served_at_id(const std::string& value);
  std::string* _internal_mutable_served_at_id();
  public:

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.SlicesSelector)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int32_t > keys_;
    mutable std::atomic<int> _keys_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr served_at_id_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class SlicesTestDataset_DatasetEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<SlicesTestDataset_DatasetEntry_DoNotUse,
    std::string, ::google::internal::federated::plan::SlicesTestData,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<SlicesTestDataset_DatasetEntry_DoNotUse,
    std::string, ::google::internal::federated::plan::SlicesTestData,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  SlicesTestDataset_DatasetEntry_DoNotUse();
  explicit PROTOBUF_CONSTEXPR SlicesTestDataset_DatasetEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit SlicesTestDataset_DatasetEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const SlicesTestDataset_DatasetEntry_DoNotUse& other);
  static const SlicesTestDataset_DatasetEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const SlicesTestDataset_DatasetEntry_DoNotUse*>(&_SlicesTestDataset_DatasetEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "google.internal.federated.plan.SlicesTestDataset.DatasetEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};

// -------------------------------------------------------------------

class SlicesTestDataset final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.SlicesTestDataset) */ {
 public:
  inline SlicesTestDataset() : SlicesTestDataset(nullptr) {}
  ~SlicesTestDataset() override;
  explicit PROTOBUF_CONSTEXPR SlicesTestDataset(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SlicesTestDataset(const SlicesTestDataset& from);
  SlicesTestDataset(SlicesTestDataset&& from) noexcept
    : SlicesTestDataset() {
    *this = ::std::move(from);
  }

  inline SlicesTestDataset& operator=(const SlicesTestDataset& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline SlicesTestDataset& operator=(SlicesTestDataset&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const SlicesTestDataset& default_instance() {
    return *internal_default_instance();
  }
  static inline const SlicesTestDataset* internal_default_instance() {
    return reinterpret_cast<const SlicesTestDataset*>(
               &_SlicesTestDataset_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    45;

  friend void swap(SlicesTestDataset& a, SlicesTestDataset& b) {
    a.Swap(&b);
  }
  inline void Swap(SlicesTestDataset* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SlicesTestDataset* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SlicesTestDataset* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SlicesTestDataset>(arena);
  }
  SlicesTestDataset* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SlicesTestDataset& from);
  void MergeFrom(const SlicesTestDataset& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SlicesTestDataset* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.SlicesTestDataset";
  }
  protected:
  explicit SlicesTestDataset(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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


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

  enum : int {
    kDatasetFieldNumber = 1,
  };
  // map<string, .google.internal.federated.plan.SlicesTestData> dataset = 1;
  int dataset_size() const;
  private:
  int _internal_dataset_size() const;
  public:
  void clear_dataset();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::SlicesTestData >&
      _internal_dataset() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::SlicesTestData >*
      _internal_mutable_dataset();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::SlicesTestData >&
      dataset() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::SlicesTestData >*
      mutable_dataset();

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.SlicesTestDataset)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::MapFieldLite<
        SlicesTestDataset_DatasetEntry_DoNotUse,
        std::string, ::google::internal::federated::plan::SlicesTestData,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> dataset_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class SlicesTestData final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.SlicesTestData) */ {
 public:
  inline SlicesTestData() : SlicesTestData(nullptr) {}
  ~SlicesTestData() override;
  explicit PROTOBUF_CONSTEXPR SlicesTestData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SlicesTestData(const SlicesTestData& from);
  SlicesTestData(SlicesTestData&& from) noexcept
    : SlicesTestData() {
    *this = ::std::move(from);
  }

  inline SlicesTestData& operator=(const SlicesTestData& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline SlicesTestData& operator=(SlicesTestData&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const SlicesTestData& default_instance() {
    return *internal_default_instance();
  }
  static inline const SlicesTestData* internal_default_instance() {
    return reinterpret_cast<const SlicesTestData*>(
               &_SlicesTestData_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    46;

  friend void swap(SlicesTestData& a, SlicesTestData& b) {
    a.Swap(&b);
  }
  inline void Swap(SlicesTestData* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SlicesTestData* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SlicesTestData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SlicesTestData>(arena);
  }
  SlicesTestData* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const SlicesTestData& from);
  void MergeFrom(const SlicesTestData& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SlicesTestData* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.SlicesTestData";
  }
  protected:
  explicit SlicesTestData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kSliceDataFieldNumber = 2,
  };
  // repeated bytes slice_data = 2;
  int slice_data_size() const;
  private:
  int _internal_slice_data_size() const;
  public:
  void clear_slice_data();
  const std::string& slice_data(int index) const;
  std::string* mutable_slice_data(int index);
  void set_slice_data(int index, const std::string& value);
  void set_slice_data(int index, std::string&& value);
  void set_slice_data(int index, const char* value);
  void set_slice_data(int index, const void* value, size_t size);
  std::string* add_slice_data();
  void add_slice_data(const std::string& value);
  void add_slice_data(std::string&& value);
  void add_slice_data(const char* value);
  void add_slice_data(const void* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& slice_data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_slice_data();
  private:
  const std::string& _internal_slice_data(int index) const;
  std::string* _internal_add_slice_data();
  public:

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.SlicesTestData)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> slice_data_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class ServerPhaseV2 final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.ServerPhaseV2) */ {
 public:
  inline ServerPhaseV2() : ServerPhaseV2(nullptr) {}
  ~ServerPhaseV2() override;
  explicit PROTOBUF_CONSTEXPR ServerPhaseV2(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ServerPhaseV2(const ServerPhaseV2& from);
  ServerPhaseV2(ServerPhaseV2&& from) noexcept
    : ServerPhaseV2() {
    *this = ::std::move(from);
  }

  inline ServerPhaseV2& operator=(const ServerPhaseV2& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline ServerPhaseV2& operator=(ServerPhaseV2&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ServerPhaseV2& default_instance() {
    return *internal_default_instance();
  }
  enum ServerPrepareIoRouterCase {
    kPrepareRouter = 4,
    SERVER_PREPARE_IO_ROUTER_NOT_SET = 0,
  };

  enum ServerResultIoRouterCase {
    kResultRouter = 6,
    SERVER_RESULT_IO_ROUTER_NOT_SET = 0,
  };

  static inline const ServerPhaseV2* internal_default_instance() {
    return reinterpret_cast<const ServerPhaseV2*>(
               &_ServerPhaseV2_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    47;

  friend void swap(ServerPhaseV2& a, ServerPhaseV2& b) {
    a.Swap(&b);
  }
  inline void Swap(ServerPhaseV2* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ServerPhaseV2* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ServerPhaseV2* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ServerPhaseV2>(arena);
  }
  ServerPhaseV2* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const ServerPhaseV2& from);
  void MergeFrom(const ServerPhaseV2& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ServerPhaseV2* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.ServerPhaseV2";
  }
  protected:
  explicit ServerPhaseV2(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kAggregationsFieldNumber = 2,
    kNameFieldNumber = 1,
    kTensorflowSpecPrepareFieldNumber = 3,
    kTensorflowSpecResultFieldNumber = 5,
    kPrepareRouterFieldNumber = 4,
    kResultRouterFieldNumber = 6,
  };
  // repeated .google.internal.federated.plan.ServerAggregationConfig aggregations = 2;
  int aggregations_size() const;
  private:
  int _internal_aggregations_size() const;
  public:
  void clear_aggregations();
  ::google::internal::federated::plan::ServerAggregationConfig* mutable_aggregations(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::ServerAggregationConfig >*
      mutable_aggregations();
  private:
  const ::google::internal::federated::plan::ServerAggregationConfig& _internal_aggregations(int index) const;
  ::google::internal::federated::plan::ServerAggregationConfig* _internal_add_aggregations();
  public:
  const ::google::internal::federated::plan::ServerAggregationConfig& aggregations(int index) const;
  ::google::internal::federated::plan::ServerAggregationConfig* add_aggregations();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::ServerAggregationConfig >&
      aggregations() const;

  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // .google.internal.federated.plan.TensorflowSpec tensorflow_spec_prepare = 3;
  bool has_tensorflow_spec_prepare() const;
  private:
  bool _internal_has_tensorflow_spec_prepare() const;
  public:
  void clear_tensorflow_spec_prepare();
  const ::google::internal::federated::plan::TensorflowSpec& tensorflow_spec_prepare() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::TensorflowSpec* release_tensorflow_spec_prepare();
  ::google::internal::federated::plan::TensorflowSpec* mutable_tensorflow_spec_prepare();
  void set_allocated_tensorflow_spec_prepare(::google::internal::federated::plan::TensorflowSpec* tensorflow_spec_prepare);
  private:
  const ::google::internal::federated::plan::TensorflowSpec& _internal_tensorflow_spec_prepare() const;
  ::google::internal::federated::plan::TensorflowSpec* _internal_mutable_tensorflow_spec_prepare();
  public:
  void unsafe_arena_set_allocated_tensorflow_spec_prepare(
      ::google::internal::federated::plan::TensorflowSpec* tensorflow_spec_prepare);
  ::google::internal::federated::plan::TensorflowSpec* unsafe_arena_release_tensorflow_spec_prepare();

  // .google.internal.federated.plan.TensorflowSpec tensorflow_spec_result = 5;
  bool has_tensorflow_spec_result() const;
  private:
  bool _internal_has_tensorflow_spec_result() const;
  public:
  void clear_tensorflow_spec_result();
  const ::google::internal::federated::plan::TensorflowSpec& tensorflow_spec_result() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::TensorflowSpec* release_tensorflow_spec_result();
  ::google::internal::federated::plan::TensorflowSpec* mutable_tensorflow_spec_result();
  void set_allocated_tensorflow_spec_result(::google::internal::federated::plan::TensorflowSpec* tensorflow_spec_result);
  private:
  const ::google::internal::federated::plan::TensorflowSpec& _internal_tensorflow_spec_result() const;
  ::google::internal::federated::plan::TensorflowSpec* _internal_mutable_tensorflow_spec_result();
  public:
  void unsafe_arena_set_allocated_tensorflow_spec_result(
      ::google::internal::federated::plan::TensorflowSpec* tensorflow_spec_result);
  ::google::internal::federated::plan::TensorflowSpec* unsafe_arena_release_tensorflow_spec_result();

  // .google.internal.federated.plan.ServerPrepareIORouter prepare_router = 4;
  bool has_prepare_router() const;
  private:
  bool _internal_has_prepare_router() const;
  public:
  void clear_prepare_router();
  const ::google::internal::federated::plan::ServerPrepareIORouter& prepare_router() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::ServerPrepareIORouter* release_prepare_router();
  ::google::internal::federated::plan::ServerPrepareIORouter* mutable_prepare_router();
  void set_allocated_prepare_router(::google::internal::federated::plan::ServerPrepareIORouter* prepare_router);
  private:
  const ::google::internal::federated::plan::ServerPrepareIORouter& _internal_prepare_router() const;
  ::google::internal::federated::plan::ServerPrepareIORouter* _internal_mutable_prepare_router();
  public:
  void unsafe_arena_set_allocated_prepare_router(
      ::google::internal::federated::plan::ServerPrepareIORouter* prepare_router);
  ::google::internal::federated::plan::ServerPrepareIORouter* unsafe_arena_release_prepare_router();

  // .google.internal.federated.plan.ServerResultIORouter result_router = 6;
  bool has_result_router() const;
  private:
  bool _internal_has_result_router() const;
  public:
  void clear_result_router();
  const ::google::internal::federated::plan::ServerResultIORouter& result_router() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::ServerResultIORouter* release_result_router();
  ::google::internal::federated::plan::ServerResultIORouter* mutable_result_router();
  void set_allocated_result_router(::google::internal::federated::plan::ServerResultIORouter* result_router);
  private:
  const ::google::internal::federated::plan::ServerResultIORouter& _internal_result_router() const;
  ::google::internal::federated::plan::ServerResultIORouter* _internal_mutable_result_router();
  public:
  void unsafe_arena_set_allocated_result_router(
      ::google::internal::federated::plan::ServerResultIORouter* result_router);
  ::google::internal::federated::plan::ServerResultIORouter* unsafe_arena_release_result_router();

  void clear_server_prepare_io_router();
  ServerPrepareIoRouterCase server_prepare_io_router_case() const;
  void clear_server_result_io_router();
  ServerResultIoRouterCase server_result_io_router_case() const;
  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.ServerPhaseV2)
 private:
  class _Internal;
  void set_has_prepare_router();
  void set_has_result_router();

  inline bool has_server_prepare_io_router() const;
  inline void clear_has_server_prepare_io_router();

  inline bool has_server_result_io_router() const;
  inline void clear_has_server_result_io_router();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::ServerAggregationConfig > aggregations_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::google::internal::federated::plan::TensorflowSpec* tensorflow_spec_prepare_;
    ::google::internal::federated::plan::TensorflowSpec* tensorflow_spec_result_;
    union ServerPrepareIoRouterUnion {
      constexpr ServerPrepareIoRouterUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::google::internal::federated::plan::ServerPrepareIORouter* prepare_router_;
    } server_prepare_io_router_;
    union ServerResultIoRouterUnion {
      constexpr ServerResultIoRouterUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::google::internal::federated::plan::ServerResultIORouter* result_router_;
    } server_result_io_router_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[2];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class ServerPrepareIORouter final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.ServerPrepareIORouter) */ {
 public:
  inline ServerPrepareIORouter() : ServerPrepareIORouter(nullptr) {}
  ~ServerPrepareIORouter() override;
  explicit PROTOBUF_CONSTEXPR ServerPrepareIORouter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ServerPrepareIORouter(const ServerPrepareIORouter& from);
  ServerPrepareIORouter(ServerPrepareIORouter&& from) noexcept
    : ServerPrepareIORouter() {
    *this = ::std::move(from);
  }

  inline ServerPrepareIORouter& operator=(const ServerPrepareIORouter& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline ServerPrepareIORouter& operator=(ServerPrepareIORouter&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ServerPrepareIORouter& default_instance() {
    return *internal_default_instance();
  }
  static inline const ServerPrepareIORouter* internal_default_instance() {
    return reinterpret_cast<const ServerPrepareIORouter*>(
               &_ServerPrepareIORouter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    48;

  friend void swap(ServerPrepareIORouter& a, ServerPrepareIORouter& b) {
    a.Swap(&b);
  }
  inline void Swap(ServerPrepareIORouter* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ServerPrepareIORouter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ServerPrepareIORouter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ServerPrepareIORouter>(arena);
  }
  ServerPrepareIORouter* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const ServerPrepareIORouter& from);
  void MergeFrom(const ServerPrepareIORouter& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ServerPrepareIORouter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.ServerPrepareIORouter";
  }
  protected:
  explicit ServerPrepareIORouter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kPrepareServerStateInputFilepathTensorNameFieldNumber = 1,
    kPrepareOutputFilepathTensorNameFieldNumber = 2,
    kPrepareIntermediateStateOutputFilepathTensorNameFieldNumber = 3,
  };
  // string prepare_server_state_input_filepath_tensor_name = 1;
  void clear_prepare_server_state_input_filepath_tensor_name();
  const std::string& prepare_server_state_input_filepath_tensor_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_prepare_server_state_input_filepath_tensor_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_prepare_server_state_input_filepath_tensor_name();
  PROTOBUF_NODISCARD std::string* release_prepare_server_state_input_filepath_tensor_name();
  void set_allocated_prepare_server_state_input_filepath_tensor_name(std::string* prepare_server_state_input_filepath_tensor_name);
  private:
  const std::string& _internal_prepare_server_state_input_filepath_tensor_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_prepare_server_state_input_filepath_tensor_name(const std::string& value);
  std::string* _internal_mutable_prepare_server_state_input_filepath_tensor_name();
  public:

  // string prepare_output_filepath_tensor_name = 2;
  void clear_prepare_output_filepath_tensor_name();
  const std::string& prepare_output_filepath_tensor_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_prepare_output_filepath_tensor_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_prepare_output_filepath_tensor_name();
  PROTOBUF_NODISCARD std::string* release_prepare_output_filepath_tensor_name();
  void set_allocated_prepare_output_filepath_tensor_name(std::string* prepare_output_filepath_tensor_name);
  private:
  const std::string& _internal_prepare_output_filepath_tensor_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_prepare_output_filepath_tensor_name(const std::string& value);
  std::string* _internal_mutable_prepare_output_filepath_tensor_name();
  public:

  // string prepare_intermediate_state_output_filepath_tensor_name = 3;
  void clear_prepare_intermediate_state_output_filepath_tensor_name();
  const std::string& prepare_intermediate_state_output_filepath_tensor_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_prepare_intermediate_state_output_filepath_tensor_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_prepare_intermediate_state_output_filepath_tensor_name();
  PROTOBUF_NODISCARD std::string* release_prepare_intermediate_state_output_filepath_tensor_name();
  void set_allocated_prepare_intermediate_state_output_filepath_tensor_name(std::string* prepare_intermediate_state_output_filepath_tensor_name);
  private:
  const std::string& _internal_prepare_intermediate_state_output_filepath_tensor_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_prepare_intermediate_state_output_filepath_tensor_name(const std::string& value);
  std::string* _internal_mutable_prepare_intermediate_state_output_filepath_tensor_name();
  public:

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.ServerPrepareIORouter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr prepare_server_state_input_filepath_tensor_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr prepare_output_filepath_tensor_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr prepare_intermediate_state_output_filepath_tensor_name_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class ServerResultIORouter final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.ServerResultIORouter) */ {
 public:
  inline ServerResultIORouter() : ServerResultIORouter(nullptr) {}
  ~ServerResultIORouter() override;
  explicit PROTOBUF_CONSTEXPR ServerResultIORouter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ServerResultIORouter(const ServerResultIORouter& from);
  ServerResultIORouter(ServerResultIORouter&& from) noexcept
    : ServerResultIORouter() {
    *this = ::std::move(from);
  }

  inline ServerResultIORouter& operator=(const ServerResultIORouter& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline ServerResultIORouter& operator=(ServerResultIORouter&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ServerResultIORouter& default_instance() {
    return *internal_default_instance();
  }
  static inline const ServerResultIORouter* internal_default_instance() {
    return reinterpret_cast<const ServerResultIORouter*>(
               &_ServerResultIORouter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    49;

  friend void swap(ServerResultIORouter& a, ServerResultIORouter& b) {
    a.Swap(&b);
  }
  inline void Swap(ServerResultIORouter* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ServerResultIORouter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ServerResultIORouter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ServerResultIORouter>(arena);
  }
  ServerResultIORouter* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const ServerResultIORouter& from);
  void MergeFrom(const ServerResultIORouter& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ServerResultIORouter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.ServerResultIORouter";
  }
  protected:
  explicit ServerResultIORouter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kResultIntermediateStateInputFilepathTensorNameFieldNumber = 1,
    kResultAggregateResultInputFilepathTensorNameFieldNumber = 2,
    kResultServerStateOutputFilepathTensorNameFieldNumber = 3,
  };
  // string result_intermediate_state_input_filepath_tensor_name = 1;
  void clear_result_intermediate_state_input_filepath_tensor_name();
  const std::string& result_intermediate_state_input_filepath_tensor_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_result_intermediate_state_input_filepath_tensor_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_result_intermediate_state_input_filepath_tensor_name();
  PROTOBUF_NODISCARD std::string* release_result_intermediate_state_input_filepath_tensor_name();
  void set_allocated_result_intermediate_state_input_filepath_tensor_name(std::string* result_intermediate_state_input_filepath_tensor_name);
  private:
  const std::string& _internal_result_intermediate_state_input_filepath_tensor_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_result_intermediate_state_input_filepath_tensor_name(const std::string& value);
  std::string* _internal_mutable_result_intermediate_state_input_filepath_tensor_name();
  public:

  // string result_aggregate_result_input_filepath_tensor_name = 2;
  void clear_result_aggregate_result_input_filepath_tensor_name();
  const std::string& result_aggregate_result_input_filepath_tensor_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_result_aggregate_result_input_filepath_tensor_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_result_aggregate_result_input_filepath_tensor_name();
  PROTOBUF_NODISCARD std::string* release_result_aggregate_result_input_filepath_tensor_name();
  void set_allocated_result_aggregate_result_input_filepath_tensor_name(std::string* result_aggregate_result_input_filepath_tensor_name);
  private:
  const std::string& _internal_result_aggregate_result_input_filepath_tensor_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_result_aggregate_result_input_filepath_tensor_name(const std::string& value);
  std::string* _internal_mutable_result_aggregate_result_input_filepath_tensor_name();
  public:

  // string result_server_state_output_filepath_tensor_name = 3;
  void clear_result_server_state_output_filepath_tensor_name();
  const std::string& result_server_state_output_filepath_tensor_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_result_server_state_output_filepath_tensor_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_result_server_state_output_filepath_tensor_name();
  PROTOBUF_NODISCARD std::string* release_result_server_state_output_filepath_tensor_name();
  void set_allocated_result_server_state_output_filepath_tensor_name(std::string* result_server_state_output_filepath_tensor_name);
  private:
  const std::string& _internal_result_server_state_output_filepath_tensor_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_result_server_state_output_filepath_tensor_name(const std::string& value);
  std::string* _internal_mutable_result_server_state_output_filepath_tensor_name();
  public:

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.ServerResultIORouter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr result_intermediate_state_input_filepath_tensor_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr result_aggregate_result_input_filepath_tensor_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr result_server_state_output_filepath_tensor_name_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class ServerAggregationConfig_IntrinsicArg final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.ServerAggregationConfig.IntrinsicArg) */ {
 public:
  inline ServerAggregationConfig_IntrinsicArg() : ServerAggregationConfig_IntrinsicArg(nullptr) {}
  ~ServerAggregationConfig_IntrinsicArg() override;
  explicit PROTOBUF_CONSTEXPR ServerAggregationConfig_IntrinsicArg(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ServerAggregationConfig_IntrinsicArg(const ServerAggregationConfig_IntrinsicArg& from);
  ServerAggregationConfig_IntrinsicArg(ServerAggregationConfig_IntrinsicArg&& from) noexcept
    : ServerAggregationConfig_IntrinsicArg() {
    *this = ::std::move(from);
  }

  inline ServerAggregationConfig_IntrinsicArg& operator=(const ServerAggregationConfig_IntrinsicArg& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline ServerAggregationConfig_IntrinsicArg& operator=(ServerAggregationConfig_IntrinsicArg&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ServerAggregationConfig_IntrinsicArg& default_instance() {
    return *internal_default_instance();
  }
  enum ArgCase {
    kInputTensor = 2,
    kStateTensor = 3,
    ARG_NOT_SET = 0,
  };

  static inline const ServerAggregationConfig_IntrinsicArg* internal_default_instance() {
    return reinterpret_cast<const ServerAggregationConfig_IntrinsicArg*>(
               &_ServerAggregationConfig_IntrinsicArg_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    50;

  friend void swap(ServerAggregationConfig_IntrinsicArg& a, ServerAggregationConfig_IntrinsicArg& b) {
    a.Swap(&b);
  }
  inline void Swap(ServerAggregationConfig_IntrinsicArg* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ServerAggregationConfig_IntrinsicArg* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ServerAggregationConfig_IntrinsicArg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ServerAggregationConfig_IntrinsicArg>(arena);
  }
  ServerAggregationConfig_IntrinsicArg* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const ServerAggregationConfig_IntrinsicArg& from);
  void MergeFrom(const ServerAggregationConfig_IntrinsicArg& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ServerAggregationConfig_IntrinsicArg* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.ServerAggregationConfig.IntrinsicArg";
  }
  protected:
  explicit ServerAggregationConfig_IntrinsicArg(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kInputTensorFieldNumber = 2,
    kStateTensorFieldNumber = 3,
  };
  // .tensorflow.TensorSpecProto input_tensor = 2;
  bool has_input_tensor() const;
  private:
  bool _internal_has_input_tensor() const;
  public:
  void clear_input_tensor();
  const ::tensorflow::TensorSpecProto& input_tensor() const;
  PROTOBUF_NODISCARD ::tensorflow::TensorSpecProto* release_input_tensor();
  ::tensorflow::TensorSpecProto* mutable_input_tensor();
  void set_allocated_input_tensor(::tensorflow::TensorSpecProto* input_tensor);
  private:
  const ::tensorflow::TensorSpecProto& _internal_input_tensor() const;
  ::tensorflow::TensorSpecProto* _internal_mutable_input_tensor();
  public:
  void unsafe_arena_set_allocated_input_tensor(
      ::tensorflow::TensorSpecProto* input_tensor);
  ::tensorflow::TensorSpecProto* unsafe_arena_release_input_tensor();

  // .tensorflow.TensorSpecProto state_tensor = 3;
  bool has_state_tensor() const;
  private:
  bool _internal_has_state_tensor() const;
  public:
  void clear_state_tensor();
  const ::tensorflow::TensorSpecProto& state_tensor() const;
  PROTOBUF_NODISCARD ::tensorflow::TensorSpecProto* release_state_tensor();
  ::tensorflow::TensorSpecProto* mutable_state_tensor();
  void set_allocated_state_tensor(::tensorflow::TensorSpecProto* state_tensor);
  private:
  const ::tensorflow::TensorSpecProto& _internal_state_tensor() const;
  ::tensorflow::TensorSpecProto* _internal_mutable_state_tensor();
  public:
  void unsafe_arena_set_allocated_state_tensor(
      ::tensorflow::TensorSpecProto* state_tensor);
  ::tensorflow::TensorSpecProto* unsafe_arena_release_state_tensor();

  void clear_arg();
  ArgCase arg_case() const;
  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.ServerAggregationConfig.IntrinsicArg)
 private:
  class _Internal;
  void set_has_input_tensor();
  void set_has_state_tensor();

  inline bool has_arg() const;
  inline void clear_has_arg();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union ArgUnion {
      constexpr ArgUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::tensorflow::TensorSpecProto* input_tensor_;
      ::tensorflow::TensorSpecProto* state_tensor_;
    } arg_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class ServerAggregationConfig final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.ServerAggregationConfig) */ {
 public:
  inline ServerAggregationConfig() : ServerAggregationConfig(nullptr) {}
  ~ServerAggregationConfig() override;
  explicit PROTOBUF_CONSTEXPR ServerAggregationConfig(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ServerAggregationConfig(const ServerAggregationConfig& from);
  ServerAggregationConfig(ServerAggregationConfig&& from) noexcept
    : ServerAggregationConfig() {
    *this = ::std::move(from);
  }

  inline ServerAggregationConfig& operator=(const ServerAggregationConfig& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline ServerAggregationConfig& operator=(ServerAggregationConfig&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ServerAggregationConfig& default_instance() {
    return *internal_default_instance();
  }
  static inline const ServerAggregationConfig* internal_default_instance() {
    return reinterpret_cast<const ServerAggregationConfig*>(
               &_ServerAggregationConfig_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    51;

  friend void swap(ServerAggregationConfig& a, ServerAggregationConfig& b) {
    a.Swap(&b);
  }
  inline void Swap(ServerAggregationConfig* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ServerAggregationConfig* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ServerAggregationConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ServerAggregationConfig>(arena);
  }
  ServerAggregationConfig* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const ServerAggregationConfig& from);
  void MergeFrom(const ServerAggregationConfig& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ServerAggregationConfig* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.ServerAggregationConfig";
  }
  protected:
  explicit ServerAggregationConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

  typedef ServerAggregationConfig_IntrinsicArg IntrinsicArg;

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

  enum : int {
    kIntrinsicArgsFieldNumber = 4,
    kOutputTensorsFieldNumber = 5,
    kInnerAggregationsFieldNumber = 6,
    kIntrinsicUriFieldNumber = 1,
  };
  // repeated .google.internal.federated.plan.ServerAggregationConfig.IntrinsicArg intrinsic_args = 4;
  int intrinsic_args_size() const;
  private:
  int _internal_intrinsic_args_size() const;
  public:
  void clear_intrinsic_args();
  ::google::internal::federated::plan::ServerAggregationConfig_IntrinsicArg* mutable_intrinsic_args(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::ServerAggregationConfig_IntrinsicArg >*
      mutable_intrinsic_args();
  private:
  const ::google::internal::federated::plan::ServerAggregationConfig_IntrinsicArg& _internal_intrinsic_args(int index) const;
  ::google::internal::federated::plan::ServerAggregationConfig_IntrinsicArg* _internal_add_intrinsic_args();
  public:
  const ::google::internal::federated::plan::ServerAggregationConfig_IntrinsicArg& intrinsic_args(int index) const;
  ::google::internal::federated::plan::ServerAggregationConfig_IntrinsicArg* add_intrinsic_args();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::ServerAggregationConfig_IntrinsicArg >&
      intrinsic_args() const;

  // repeated .tensorflow.TensorSpecProto output_tensors = 5;
  int output_tensors_size() const;
  private:
  int _internal_output_tensors_size() const;
  public:
  void clear_output_tensors();
  ::tensorflow::TensorSpecProto* mutable_output_tensors(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorSpecProto >*
      mutable_output_tensors();
  private:
  const ::tensorflow::TensorSpecProto& _internal_output_tensors(int index) const;
  ::tensorflow::TensorSpecProto* _internal_add_output_tensors();
  public:
  const ::tensorflow::TensorSpecProto& output_tensors(int index) const;
  ::tensorflow::TensorSpecProto* add_output_tensors();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorSpecProto >&
      output_tensors() const;

  // repeated .google.internal.federated.plan.ServerAggregationConfig inner_aggregations = 6;
  int inner_aggregations_size() const;
  private:
  int _internal_inner_aggregations_size() const;
  public:
  void clear_inner_aggregations();
  ::google::internal::federated::plan::ServerAggregationConfig* mutable_inner_aggregations(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::ServerAggregationConfig >*
      mutable_inner_aggregations();
  private:
  const ::google::internal::federated::plan::ServerAggregationConfig& _internal_inner_aggregations(int index) const;
  ::google::internal::federated::plan::ServerAggregationConfig* _internal_add_inner_aggregations();
  public:
  const ::google::internal::federated::plan::ServerAggregationConfig& inner_aggregations(int index) const;
  ::google::internal::federated::plan::ServerAggregationConfig* add_inner_aggregations();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::ServerAggregationConfig >&
      inner_aggregations() const;

  // string intrinsic_uri = 1;
  void clear_intrinsic_uri();
  const std::string& intrinsic_uri() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_intrinsic_uri(ArgT0&& arg0, ArgT... args);
  std::string* mutable_intrinsic_uri();
  PROTOBUF_NODISCARD std::string* release_intrinsic_uri();
  void set_allocated_intrinsic_uri(std::string* intrinsic_uri);
  private:
  const std::string& _internal_intrinsic_uri() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_intrinsic_uri(const std::string& value);
  std::string* _internal_mutable_intrinsic_uri();
  public:

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.ServerAggregationConfig)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::ServerAggregationConfig_IntrinsicArg > intrinsic_args_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorSpecProto > output_tensors_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::ServerAggregationConfig > inner_aggregations_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr intrinsic_uri_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class ServerPhase final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.ServerPhase) */ {
 public:
  inline ServerPhase() : ServerPhase(nullptr) {}
  ~ServerPhase() override;
  explicit PROTOBUF_CONSTEXPR ServerPhase(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ServerPhase(const ServerPhase& from);
  ServerPhase(ServerPhase&& from) noexcept
    : ServerPhase() {
    *this = ::std::move(from);
  }

  inline ServerPhase& operator=(const ServerPhase& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline ServerPhase& operator=(ServerPhase&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ServerPhase& default_instance() {
    return *internal_default_instance();
  }
  static inline const ServerPhase* internal_default_instance() {
    return reinterpret_cast<const ServerPhase*>(
               &_ServerPhase_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    52;

  friend void swap(ServerPhase& a, ServerPhase& b) {
    a.Swap(&b);
  }
  inline void Swap(ServerPhase* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ServerPhase* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ServerPhase* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ServerPhase>(arena);
  }
  ServerPhase* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const ServerPhase& from);
  void MergeFrom(const ServerPhase& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ServerPhase* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.ServerPhase";
  }
  protected:
  explicit ServerPhase(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kMetricsFieldNumber = 6,
    kPhaseInitOpFieldNumber = 1,
    kAggregateIntoAccumulatorsOpFieldNumber = 4,
    kApplyAggregratedUpdatesOpFieldNumber = 5,
    kNameFieldNumber = 8,
    kIntermediateAggregateIntoAccumulatorsOpFieldNumber = 11,
    kWriteClientInitFieldNumber = 2,
    kReadUpdateFieldNumber = 3,
    kWriteIntermediateUpdateFieldNumber = 7,
    kReadIntermediateUpdateFieldNumber = 9,
    kReadAggregatedUpdateFieldNumber = 10,
    kWriteAccumulatorsFieldNumber = 12,
  };
  // repeated .google.internal.federated.plan.Metric metrics = 6;
  int metrics_size() const;
  private:
  int _internal_metrics_size() const;
  public:
  void clear_metrics();
  ::google::internal::federated::plan::Metric* mutable_metrics(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::Metric >*
      mutable_metrics();
  private:
  const ::google::internal::federated::plan::Metric& _internal_metrics(int index) const;
  ::google::internal::federated::plan::Metric* _internal_add_metrics();
  public:
  const ::google::internal::federated::plan::Metric& metrics(int index) const;
  ::google::internal::federated::plan::Metric* add_metrics();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::Metric >&
      metrics() const;

  // string phase_init_op = 1;
  void clear_phase_init_op();
  const std::string& phase_init_op() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_phase_init_op(ArgT0&& arg0, ArgT... args);
  std::string* mutable_phase_init_op();
  PROTOBUF_NODISCARD std::string* release_phase_init_op();
  void set_allocated_phase_init_op(std::string* phase_init_op);
  private:
  const std::string& _internal_phase_init_op() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_phase_init_op(const std::string& value);
  std::string* _internal_mutable_phase_init_op();
  public:

  // string aggregate_into_accumulators_op = 4;
  void clear_aggregate_into_accumulators_op();
  const std::string& aggregate_into_accumulators_op() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_aggregate_into_accumulators_op(ArgT0&& arg0, ArgT... args);
  std::string* mutable_aggregate_into_accumulators_op();
  PROTOBUF_NODISCARD std::string* release_aggregate_into_accumulators_op();
  void set_allocated_aggregate_into_accumulators_op(std::string* aggregate_into_accumulators_op);
  private:
  const std::string& _internal_aggregate_into_accumulators_op() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_aggregate_into_accumulators_op(const std::string& value);
  std::string* _internal_mutable_aggregate_into_accumulators_op();
  public:

  // string apply_aggregrated_updates_op = 5;
  void clear_apply_aggregrated_updates_op();
  const std::string& apply_aggregrated_updates_op() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_apply_aggregrated_updates_op(ArgT0&& arg0, ArgT... args);
  std::string* mutable_apply_aggregrated_updates_op();
  PROTOBUF_NODISCARD std::string* release_apply_aggregrated_updates_op();
  void set_allocated_apply_aggregrated_updates_op(std::string* apply_aggregrated_updates_op);
  private:
  const std::string& _internal_apply_aggregrated_updates_op() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_apply_aggregrated_updates_op(const std::string& value);
  std::string* _internal_mutable_apply_aggregrated_updates_op();
  public:

  // string name = 8;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // string intermediate_aggregate_into_accumulators_op = 11;
  void clear_intermediate_aggregate_into_accumulators_op();
  const std::string& intermediate_aggregate_into_accumulators_op() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_intermediate_aggregate_into_accumulators_op(ArgT0&& arg0, ArgT... args);
  std::string* mutable_intermediate_aggregate_into_accumulators_op();
  PROTOBUF_NODISCARD std::string* release_intermediate_aggregate_into_accumulators_op();
  void set_allocated_intermediate_aggregate_into_accumulators_op(std::string* intermediate_aggregate_into_accumulators_op);
  private:
  const std::string& _internal_intermediate_aggregate_into_accumulators_op() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_intermediate_aggregate_into_accumulators_op(const std::string& value);
  std::string* _internal_mutable_intermediate_aggregate_into_accumulators_op();
  public:

  // .google.internal.federated.plan.CheckpointOp write_client_init = 2;
  bool has_write_client_init() const;
  private:
  bool _internal_has_write_client_init() const;
  public:
  void clear_write_client_init();
  const ::google::internal::federated::plan::CheckpointOp& write_client_init() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::CheckpointOp* release_write_client_init();
  ::google::internal::federated::plan::CheckpointOp* mutable_write_client_init();
  void set_allocated_write_client_init(::google::internal::federated::plan::CheckpointOp* write_client_init);
  private:
  const ::google::internal::federated::plan::CheckpointOp& _internal_write_client_init() const;
  ::google::internal::federated::plan::CheckpointOp* _internal_mutable_write_client_init();
  public:
  void unsafe_arena_set_allocated_write_client_init(
      ::google::internal::federated::plan::CheckpointOp* write_client_init);
  ::google::internal::federated::plan::CheckpointOp* unsafe_arena_release_write_client_init();

  // .google.internal.federated.plan.CheckpointOp read_update = 3;
  bool has_read_update() const;
  private:
  bool _internal_has_read_update() const;
  public:
  void clear_read_update();
  const ::google::internal::federated::plan::CheckpointOp& read_update() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::CheckpointOp* release_read_update();
  ::google::internal::federated::plan::CheckpointOp* mutable_read_update();
  void set_allocated_read_update(::google::internal::federated::plan::CheckpointOp* read_update);
  private:
  const ::google::internal::federated::plan::CheckpointOp& _internal_read_update() const;
  ::google::internal::federated::plan::CheckpointOp* _internal_mutable_read_update();
  public:
  void unsafe_arena_set_allocated_read_update(
      ::google::internal::federated::plan::CheckpointOp* read_update);
  ::google::internal::federated::plan::CheckpointOp* unsafe_arena_release_read_update();

  // .google.internal.federated.plan.CheckpointOp write_intermediate_update = 7;
  bool has_write_intermediate_update() const;
  private:
  bool _internal_has_write_intermediate_update() const;
  public:
  void clear_write_intermediate_update();
  const ::google::internal::federated::plan::CheckpointOp& write_intermediate_update() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::CheckpointOp* release_write_intermediate_update();
  ::google::internal::federated::plan::CheckpointOp* mutable_write_intermediate_update();
  void set_allocated_write_intermediate_update(::google::internal::federated::plan::CheckpointOp* write_intermediate_update);
  private:
  const ::google::internal::federated::plan::CheckpointOp& _internal_write_intermediate_update() const;
  ::google::internal::federated::plan::CheckpointOp* _internal_mutable_write_intermediate_update();
  public:
  void unsafe_arena_set_allocated_write_intermediate_update(
      ::google::internal::federated::plan::CheckpointOp* write_intermediate_update);
  ::google::internal::federated::plan::CheckpointOp* unsafe_arena_release_write_intermediate_update();

  // .google.internal.federated.plan.CheckpointOp read_intermediate_update = 9;
  bool has_read_intermediate_update() const;
  private:
  bool _internal_has_read_intermediate_update() const;
  public:
  void clear_read_intermediate_update();
  const ::google::internal::federated::plan::CheckpointOp& read_intermediate_update() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::CheckpointOp* release_read_intermediate_update();
  ::google::internal::federated::plan::CheckpointOp* mutable_read_intermediate_update();
  void set_allocated_read_intermediate_update(::google::internal::federated::plan::CheckpointOp* read_intermediate_update);
  private:
  const ::google::internal::federated::plan::CheckpointOp& _internal_read_intermediate_update() const;
  ::google::internal::federated::plan::CheckpointOp* _internal_mutable_read_intermediate_update();
  public:
  void unsafe_arena_set_allocated_read_intermediate_update(
      ::google::internal::federated::plan::CheckpointOp* read_intermediate_update);
  ::google::internal::federated::plan::CheckpointOp* unsafe_arena_release_read_intermediate_update();

  // .google.internal.federated.plan.CheckpointOp read_aggregated_update = 10;
  bool has_read_aggregated_update() const;
  private:
  bool _internal_has_read_aggregated_update() const;
  public:
  void clear_read_aggregated_update();
  const ::google::internal::federated::plan::CheckpointOp& read_aggregated_update() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::CheckpointOp* release_read_aggregated_update();
  ::google::internal::federated::plan::CheckpointOp* mutable_read_aggregated_update();
  void set_allocated_read_aggregated_update(::google::internal::federated::plan::CheckpointOp* read_aggregated_update);
  private:
  const ::google::internal::federated::plan::CheckpointOp& _internal_read_aggregated_update() const;
  ::google::internal::federated::plan::CheckpointOp* _internal_mutable_read_aggregated_update();
  public:
  void unsafe_arena_set_allocated_read_aggregated_update(
      ::google::internal::federated::plan::CheckpointOp* read_aggregated_update);
  ::google::internal::federated::plan::CheckpointOp* unsafe_arena_release_read_aggregated_update();

  // .google.internal.federated.plan.CheckpointOp write_accumulators = 12;
  bool has_write_accumulators() const;
  private:
  bool _internal_has_write_accumulators() const;
  public:
  void clear_write_accumulators();
  const ::google::internal::federated::plan::CheckpointOp& write_accumulators() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::CheckpointOp* release_write_accumulators();
  ::google::internal::federated::plan::CheckpointOp* mutable_write_accumulators();
  void set_allocated_write_accumulators(::google::internal::federated::plan::CheckpointOp* write_accumulators);
  private:
  const ::google::internal::federated::plan::CheckpointOp& _internal_write_accumulators() const;
  ::google::internal::federated::plan::CheckpointOp* _internal_mutable_write_accumulators();
  public:
  void unsafe_arena_set_allocated_write_accumulators(
      ::google::internal::federated::plan::CheckpointOp* write_accumulators);
  ::google::internal::federated::plan::CheckpointOp* unsafe_arena_release_write_accumulators();

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.ServerPhase)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::Metric > metrics_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr phase_init_op_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr aggregate_into_accumulators_op_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr apply_aggregrated_updates_op_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr intermediate_aggregate_into_accumulators_op_;
    ::google::internal::federated::plan::CheckpointOp* write_client_init_;
    ::google::internal::federated::plan::CheckpointOp* read_update_;
    ::google::internal::federated::plan::CheckpointOp* write_intermediate_update_;
    ::google::internal::federated::plan::CheckpointOp* read_intermediate_update_;
    ::google::internal::federated::plan::CheckpointOp* read_aggregated_update_;
    ::google::internal::federated::plan::CheckpointOp* write_accumulators_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class ServerEligibilityComputationPhase final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.ServerEligibilityComputationPhase) */ {
 public:
  inline ServerEligibilityComputationPhase() : ServerEligibilityComputationPhase(nullptr) {}
  ~ServerEligibilityComputationPhase() override;
  explicit PROTOBUF_CONSTEXPR ServerEligibilityComputationPhase(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ServerEligibilityComputationPhase(const ServerEligibilityComputationPhase& from);
  ServerEligibilityComputationPhase(ServerEligibilityComputationPhase&& from) noexcept
    : ServerEligibilityComputationPhase() {
    *this = ::std::move(from);
  }

  inline ServerEligibilityComputationPhase& operator=(const ServerEligibilityComputationPhase& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline ServerEligibilityComputationPhase& operator=(ServerEligibilityComputationPhase&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ServerEligibilityComputationPhase& default_instance() {
    return *internal_default_instance();
  }
  enum ServerEligibilityIoRouterCase {
    kTaskEligibility = 3,
    SERVER_ELIGIBILITY_IO_ROUTER_NOT_SET = 0,
  };

  static inline const ServerEligibilityComputationPhase* internal_default_instance() {
    return reinterpret_cast<const ServerEligibilityComputationPhase*>(
               &_ServerEligibilityComputationPhase_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    53;

  friend void swap(ServerEligibilityComputationPhase& a, ServerEligibilityComputationPhase& b) {
    a.Swap(&b);
  }
  inline void Swap(ServerEligibilityComputationPhase* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ServerEligibilityComputationPhase* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ServerEligibilityComputationPhase* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ServerEligibilityComputationPhase>(arena);
  }
  ServerEligibilityComputationPhase* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const ServerEligibilityComputationPhase& from);
  void MergeFrom(const ServerEligibilityComputationPhase& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ServerEligibilityComputationPhase* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.ServerEligibilityComputationPhase";
  }
  protected:
  explicit ServerEligibilityComputationPhase(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kTargetNodeNamesFieldNumber = 2,
    kNameFieldNumber = 1,
    kTaskEligibilityFieldNumber = 3,
  };
  // repeated string target_node_names = 2;
  int target_node_names_size() const;
  private:
  int _internal_target_node_names_size() const;
  public:
  void clear_target_node_names();
  const std::string& target_node_names(int index) const;
  std::string* mutable_target_node_names(int index);
  void set_target_node_names(int index, const std::string& value);
  void set_target_node_names(int index, std::string&& value);
  void set_target_node_names(int index, const char* value);
  void set_target_node_names(int index, const char* value, size_t size);
  std::string* add_target_node_names();
  void add_target_node_names(const std::string& value);
  void add_target_node_names(std::string&& value);
  void add_target_node_names(const char* value);
  void add_target_node_names(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& target_node_names() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_target_node_names();
  private:
  const std::string& _internal_target_node_names(int index) const;
  std::string* _internal_add_target_node_names();
  public:

  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // .google.internal.federated.plan.TEContextServerEligibilityIORouter task_eligibility = 3 [lazy = true];
  bool has_task_eligibility() const;
  private:
  bool _internal_has_task_eligibility() const;
  public:
  void clear_task_eligibility();
  const ::google::internal::federated::plan::TEContextServerEligibilityIORouter& task_eligibility() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::TEContextServerEligibilityIORouter* release_task_eligibility();
  ::google::internal::federated::plan::TEContextServerEligibilityIORouter* mutable_task_eligibility();
  void set_allocated_task_eligibility(::google::internal::federated::plan::TEContextServerEligibilityIORouter* task_eligibility);
  private:
  const ::google::internal::federated::plan::TEContextServerEligibilityIORouter& _internal_task_eligibility() const;
  ::google::internal::federated::plan::TEContextServerEligibilityIORouter* _internal_mutable_task_eligibility();
  public:
  void unsafe_arena_set_allocated_task_eligibility(
      ::google::internal::federated::plan::TEContextServerEligibilityIORouter* task_eligibility);
  ::google::internal::federated::plan::TEContextServerEligibilityIORouter* unsafe_arena_release_task_eligibility();

  void clear_server_eligibility_io_router();
  ServerEligibilityIoRouterCase server_eligibility_io_router_case() const;
  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.ServerEligibilityComputationPhase)
 private:
  class _Internal;
  void set_has_task_eligibility();

  inline bool has_server_eligibility_io_router() const;
  inline void clear_has_server_eligibility_io_router();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> target_node_names_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    union ServerEligibilityIoRouterUnion {
      constexpr ServerEligibilityIoRouterUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::google::internal::federated::plan::TEContextServerEligibilityIORouter* task_eligibility_;
    } server_eligibility_io_router_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class TEContextServerEligibilityIORouter final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.TEContextServerEligibilityIORouter) */ {
 public:
  inline TEContextServerEligibilityIORouter() : TEContextServerEligibilityIORouter(nullptr) {}
  ~TEContextServerEligibilityIORouter() override;
  explicit PROTOBUF_CONSTEXPR TEContextServerEligibilityIORouter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  TEContextServerEligibilityIORouter(const TEContextServerEligibilityIORouter& from);
  TEContextServerEligibilityIORouter(TEContextServerEligibilityIORouter&& from) noexcept
    : TEContextServerEligibilityIORouter() {
    *this = ::std::move(from);
  }

  inline TEContextServerEligibilityIORouter& operator=(const TEContextServerEligibilityIORouter& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline TEContextServerEligibilityIORouter& operator=(TEContextServerEligibilityIORouter&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const TEContextServerEligibilityIORouter& default_instance() {
    return *internal_default_instance();
  }
  static inline const TEContextServerEligibilityIORouter* internal_default_instance() {
    return reinterpret_cast<const TEContextServerEligibilityIORouter*>(
               &_TEContextServerEligibilityIORouter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    54;

  friend void swap(TEContextServerEligibilityIORouter& a, TEContextServerEligibilityIORouter& b) {
    a.Swap(&b);
  }
  inline void Swap(TEContextServerEligibilityIORouter* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TEContextServerEligibilityIORouter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  TEContextServerEligibilityIORouter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TEContextServerEligibilityIORouter>(arena);
  }
  TEContextServerEligibilityIORouter* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const TEContextServerEligibilityIORouter& from);
  void MergeFrom(const TEContextServerEligibilityIORouter& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(TEContextServerEligibilityIORouter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.TEContextServerEligibilityIORouter";
  }
  protected:
  explicit TEContextServerEligibilityIORouter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kContextProtoInputTensorNameFieldNumber = 1,
    kOutputFilepathTensorNameFieldNumber = 2,
  };
  // string context_proto_input_tensor_name = 1;
  void clear_context_proto_input_tensor_name();
  const std::string& context_proto_input_tensor_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_context_proto_input_tensor_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_context_proto_input_tensor_name();
  PROTOBUF_NODISCARD std::string* release_context_proto_input_tensor_name();
  void set_allocated_context_proto_input_tensor_name(std::string* context_proto_input_tensor_name);
  private:
  const std::string& _internal_context_proto_input_tensor_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_context_proto_input_tensor_name(const std::string& value);
  std::string* _internal_mutable_context_proto_input_tensor_name();
  public:

  // string output_filepath_tensor_name = 2;
  void clear_output_filepath_tensor_name();
  const std::string& output_filepath_tensor_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_output_filepath_tensor_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_output_filepath_tensor_name();
  PROTOBUF_NODISCARD std::string* release_output_filepath_tensor_name();
  void set_allocated_output_filepath_tensor_name(std::string* output_filepath_tensor_name);
  private:
  const std::string& _internal_output_filepath_tensor_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_output_filepath_tensor_name(const std::string& value);
  std::string* _internal_mutable_output_filepath_tensor_name();
  public:

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.TEContextServerEligibilityIORouter)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr context_proto_input_tensor_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr output_filepath_tensor_name_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class Plan_Phase final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.Plan.Phase) */ {
 public:
  inline Plan_Phase() : Plan_Phase(nullptr) {}
  ~Plan_Phase() override;
  explicit PROTOBUF_CONSTEXPR Plan_Phase(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Plan_Phase(const Plan_Phase& from);
  Plan_Phase(Plan_Phase&& from) noexcept
    : Plan_Phase() {
    *this = ::std::move(from);
  }

  inline Plan_Phase& operator=(const Plan_Phase& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline Plan_Phase& operator=(Plan_Phase&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const Plan_Phase& default_instance() {
    return *internal_default_instance();
  }
  static inline const Plan_Phase* internal_default_instance() {
    return reinterpret_cast<const Plan_Phase*>(
               &_Plan_Phase_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    55;

  friend void swap(Plan_Phase& a, Plan_Phase& b) {
    a.Swap(&b);
  }
  inline void Swap(Plan_Phase* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Plan_Phase* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Plan_Phase* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Plan_Phase>(arena);
  }
  Plan_Phase* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const Plan_Phase& from);
  void MergeFrom(const Plan_Phase& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Plan_Phase* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.Plan.Phase";
  }
  protected:
  explicit Plan_Phase(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kClientPhaseFieldNumber = 1,
    kServerPhaseFieldNumber = 2,
    kServerEligibilityPhaseFieldNumber = 3,
    kServerPhaseV2FieldNumber = 4,
  };
  // .google.internal.federated.plan.ClientPhase client_phase = 1;
  bool has_client_phase() const;
  private:
  bool _internal_has_client_phase() const;
  public:
  void clear_client_phase();
  const ::google::internal::federated::plan::ClientPhase& client_phase() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::ClientPhase* release_client_phase();
  ::google::internal::federated::plan::ClientPhase* mutable_client_phase();
  void set_allocated_client_phase(::google::internal::federated::plan::ClientPhase* client_phase);
  private:
  const ::google::internal::federated::plan::ClientPhase& _internal_client_phase() const;
  ::google::internal::federated::plan::ClientPhase* _internal_mutable_client_phase();
  public:
  void unsafe_arena_set_allocated_client_phase(
      ::google::internal::federated::plan::ClientPhase* client_phase);
  ::google::internal::federated::plan::ClientPhase* unsafe_arena_release_client_phase();

  // .google.internal.federated.plan.ServerPhase server_phase = 2;
  bool has_server_phase() const;
  private:
  bool _internal_has_server_phase() const;
  public:
  void clear_server_phase();
  const ::google::internal::federated::plan::ServerPhase& server_phase() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::ServerPhase* release_server_phase();
  ::google::internal::federated::plan::ServerPhase* mutable_server_phase();
  void set_allocated_server_phase(::google::internal::federated::plan::ServerPhase* server_phase);
  private:
  const ::google::internal::federated::plan::ServerPhase& _internal_server_phase() const;
  ::google::internal::federated::plan::ServerPhase* _internal_mutable_server_phase();
  public:
  void unsafe_arena_set_allocated_server_phase(
      ::google::internal::federated::plan::ServerPhase* server_phase);
  ::google::internal::federated::plan::ServerPhase* unsafe_arena_release_server_phase();

  // .google.internal.federated.plan.ServerEligibilityComputationPhase server_eligibility_phase = 3;
  bool has_server_eligibility_phase() const;
  private:
  bool _internal_has_server_eligibility_phase() const;
  public:
  void clear_server_eligibility_phase();
  const ::google::internal::federated::plan::ServerEligibilityComputationPhase& server_eligibility_phase() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::ServerEligibilityComputationPhase* release_server_eligibility_phase();
  ::google::internal::federated::plan::ServerEligibilityComputationPhase* mutable_server_eligibility_phase();
  void set_allocated_server_eligibility_phase(::google::internal::federated::plan::ServerEligibilityComputationPhase* server_eligibility_phase);
  private:
  const ::google::internal::federated::plan::ServerEligibilityComputationPhase& _internal_server_eligibility_phase() const;
  ::google::internal::federated::plan::ServerEligibilityComputationPhase* _internal_mutable_server_eligibility_phase();
  public:
  void unsafe_arena_set_allocated_server_eligibility_phase(
      ::google::internal::federated::plan::ServerEligibilityComputationPhase* server_eligibility_phase);
  ::google::internal::federated::plan::ServerEligibilityComputationPhase* unsafe_arena_release_server_eligibility_phase();

  // .google.internal.federated.plan.ServerPhaseV2 server_phase_v2 = 4;
  bool has_server_phase_v2() const;
  private:
  bool _internal_has_server_phase_v2() const;
  public:
  void clear_server_phase_v2();
  const ::google::internal::federated::plan::ServerPhaseV2& server_phase_v2() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::ServerPhaseV2* release_server_phase_v2();
  ::google::internal::federated::plan::ServerPhaseV2* mutable_server_phase_v2();
  void set_allocated_server_phase_v2(::google::internal::federated::plan::ServerPhaseV2* server_phase_v2);
  private:
  const ::google::internal::federated::plan::ServerPhaseV2& _internal_server_phase_v2() const;
  ::google::internal::federated::plan::ServerPhaseV2* _internal_mutable_server_phase_v2();
  public:
  void unsafe_arena_set_allocated_server_phase_v2(
      ::google::internal::federated::plan::ServerPhaseV2* server_phase_v2);
  ::google::internal::federated::plan::ServerPhaseV2* unsafe_arena_release_server_phase_v2();

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.Plan.Phase)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::google::internal::federated::plan::ClientPhase* client_phase_;
    ::google::internal::federated::plan::ServerPhase* server_phase_;
    ::google::internal::federated::plan::ServerEligibilityComputationPhase* server_eligibility_phase_;
    ::google::internal::federated::plan::ServerPhaseV2* server_phase_v2_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class Plan final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.Plan) */ {
 public:
  inline Plan() : Plan(nullptr) {}
  ~Plan() override;
  explicit PROTOBUF_CONSTEXPR Plan(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Plan(const Plan& from);
  Plan(Plan&& from) noexcept
    : Plan() {
    *this = ::std::move(from);
  }

  inline Plan& operator=(const Plan& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline Plan& operator=(Plan&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const Plan& default_instance() {
    return *internal_default_instance();
  }
  static inline const Plan* internal_default_instance() {
    return reinterpret_cast<const Plan*>(
               &_Plan_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    56;

  friend void swap(Plan& a, Plan& b) {
    a.Swap(&b);
  }
  inline void Swap(Plan* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Plan* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Plan* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Plan>(arena);
  }
  Plan* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const Plan& from);
  void MergeFrom(const Plan& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Plan* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.Plan";
  }
  protected:
  explicit Plan(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

  typedef Plan_Phase Phase;

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

  enum : int {
    kPhaseFieldNumber = 4,
    kMetricsFieldNumber = 6,
    kOutputMetricsFieldNumber = 10,
    kClientTfliteGraphBytesFieldNumber = 12,
    kServerSavepointFieldNumber = 2,
    kServerGraphBytesFieldNumber = 7,
    kClientGraphBytesFieldNumber = 8,
    kTensorflowConfigProtoFieldNumber = 11,
    kServerGraphPrepareBytesFieldNumber = 13,
    kServerGraphResultBytesFieldNumber = 14,
    kVersionFieldNumber = 9,
  };
  // repeated .google.internal.federated.plan.Plan.Phase phase = 4;
  int phase_size() const;
  private:
  int _internal_phase_size() const;
  public:
  void clear_phase();
  ::google::internal::federated::plan::Plan_Phase* mutable_phase(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::Plan_Phase >*
      mutable_phase();
  private:
  const ::google::internal::federated::plan::Plan_Phase& _internal_phase(int index) const;
  ::google::internal::federated::plan::Plan_Phase* _internal_add_phase();
  public:
  const ::google::internal::federated::plan::Plan_Phase& phase(int index) const;
  ::google::internal::federated::plan::Plan_Phase* add_phase();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::Plan_Phase >&
      phase() const;

  // repeated .google.internal.federated.plan.Metric metrics = 6;
  int metrics_size() const;
  private:
  int _internal_metrics_size() const;
  public:
  void clear_metrics();
  ::google::internal::federated::plan::Metric* mutable_metrics(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::Metric >*
      mutable_metrics();
  private:
  const ::google::internal::federated::plan::Metric& _internal_metrics(int index) const;
  ::google::internal::federated::plan::Metric* _internal_add_metrics();
  public:
  const ::google::internal::federated::plan::Metric& metrics(int index) const;
  ::google::internal::federated::plan::Metric* add_metrics();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::Metric >&
      metrics() const;

  // repeated .google.internal.federated.plan.OutputMetric output_metrics = 10;
  int output_metrics_size() const;
  private:
  int _internal_output_metrics_size() const;
  public:
  void clear_output_metrics();
  ::google::internal::federated::plan::OutputMetric* mutable_output_metrics(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::OutputMetric >*
      mutable_output_metrics();
  private:
  const ::google::internal::federated::plan::OutputMetric& _internal_output_metrics(int index) const;
  ::google::internal::federated::plan::OutputMetric* _internal_add_output_metrics();
  public:
  const ::google::internal::federated::plan::OutputMetric& output_metrics(int index) const;
  ::google::internal::federated::plan::OutputMetric* add_output_metrics();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::OutputMetric >&
      output_metrics() const;

  // bytes client_tflite_graph_bytes = 12;
  void clear_client_tflite_graph_bytes();
  const std::string& client_tflite_graph_bytes() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_client_tflite_graph_bytes(ArgT0&& arg0, ArgT... args);
  std::string* mutable_client_tflite_graph_bytes();
  PROTOBUF_NODISCARD std::string* release_client_tflite_graph_bytes();
  void set_allocated_client_tflite_graph_bytes(std::string* client_tflite_graph_bytes);
  private:
  const std::string& _internal_client_tflite_graph_bytes() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_client_tflite_graph_bytes(const std::string& value);
  std::string* _internal_mutable_client_tflite_graph_bytes();
  public:

  // .google.internal.federated.plan.CheckpointOp server_savepoint = 2;
  bool has_server_savepoint() const;
  private:
  bool _internal_has_server_savepoint() const;
  public:
  void clear_server_savepoint();
  const ::google::internal::federated::plan::CheckpointOp& server_savepoint() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::CheckpointOp* release_server_savepoint();
  ::google::internal::federated::plan::CheckpointOp* mutable_server_savepoint();
  void set_allocated_server_savepoint(::google::internal::federated::plan::CheckpointOp* server_savepoint);
  private:
  const ::google::internal::federated::plan::CheckpointOp& _internal_server_savepoint() const;
  ::google::internal::federated::plan::CheckpointOp* _internal_mutable_server_savepoint();
  public:
  void unsafe_arena_set_allocated_server_savepoint(
      ::google::internal::federated::plan::CheckpointOp* server_savepoint);
  ::google::internal::federated::plan::CheckpointOp* unsafe_arena_release_server_savepoint();

  // .google.protobuf.Any server_graph_bytes = 7;
  bool has_server_graph_bytes() const;
  private:
  bool _internal_has_server_graph_bytes() const;
  public:
  void clear_server_graph_bytes();
  const ::PROTOBUF_NAMESPACE_ID::Any& server_graph_bytes() const;
  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_server_graph_bytes();
  ::PROTOBUF_NAMESPACE_ID::Any* mutable_server_graph_bytes();
  void set_allocated_server_graph_bytes(::PROTOBUF_NAMESPACE_ID::Any* server_graph_bytes);
  private:
  const ::PROTOBUF_NAMESPACE_ID::Any& _internal_server_graph_bytes() const;
  ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_server_graph_bytes();
  public:
  void unsafe_arena_set_allocated_server_graph_bytes(
      ::PROTOBUF_NAMESPACE_ID::Any* server_graph_bytes);
  ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_server_graph_bytes();

  // .google.protobuf.Any client_graph_bytes = 8;
  bool has_client_graph_bytes() const;
  private:
  bool _internal_has_client_graph_bytes() const;
  public:
  void clear_client_graph_bytes();
  const ::PROTOBUF_NAMESPACE_ID::Any& client_graph_bytes() const;
  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_client_graph_bytes();
  ::PROTOBUF_NAMESPACE_ID::Any* mutable_client_graph_bytes();
  void set_allocated_client_graph_bytes(::PROTOBUF_NAMESPACE_ID::Any* client_graph_bytes);
  private:
  const ::PROTOBUF_NAMESPACE_ID::Any& _internal_client_graph_bytes() const;
  ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_client_graph_bytes();
  public:
  void unsafe_arena_set_allocated_client_graph_bytes(
      ::PROTOBUF_NAMESPACE_ID::Any* client_graph_bytes);
  ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_client_graph_bytes();

  // .google.protobuf.Any tensorflow_config_proto = 11;
  bool has_tensorflow_config_proto() const;
  private:
  bool _internal_has_tensorflow_config_proto() const;
  public:
  void clear_tensorflow_config_proto();
  const ::PROTOBUF_NAMESPACE_ID::Any& tensorflow_config_proto() const;
  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_tensorflow_config_proto();
  ::PROTOBUF_NAMESPACE_ID::Any* mutable_tensorflow_config_proto();
  void set_allocated_tensorflow_config_proto(::PROTOBUF_NAMESPACE_ID::Any* tensorflow_config_proto);
  private:
  const ::PROTOBUF_NAMESPACE_ID::Any& _internal_tensorflow_config_proto() const;
  ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_tensorflow_config_proto();
  public:
  void unsafe_arena_set_allocated_tensorflow_config_proto(
      ::PROTOBUF_NAMESPACE_ID::Any* tensorflow_config_proto);
  ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_tensorflow_config_proto();

  // .google.protobuf.Any server_graph_prepare_bytes = 13;
  bool has_server_graph_prepare_bytes() const;
  private:
  bool _internal_has_server_graph_prepare_bytes() const;
  public:
  void clear_server_graph_prepare_bytes();
  const ::PROTOBUF_NAMESPACE_ID::Any& server_graph_prepare_bytes() const;
  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_server_graph_prepare_bytes();
  ::PROTOBUF_NAMESPACE_ID::Any* mutable_server_graph_prepare_bytes();
  void set_allocated_server_graph_prepare_bytes(::PROTOBUF_NAMESPACE_ID::Any* server_graph_prepare_bytes);
  private:
  const ::PROTOBUF_NAMESPACE_ID::Any& _internal_server_graph_prepare_bytes() const;
  ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_server_graph_prepare_bytes();
  public:
  void unsafe_arena_set_allocated_server_graph_prepare_bytes(
      ::PROTOBUF_NAMESPACE_ID::Any* server_graph_prepare_bytes);
  ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_server_graph_prepare_bytes();

  // .google.protobuf.Any server_graph_result_bytes = 14;
  bool has_server_graph_result_bytes() const;
  private:
  bool _internal_has_server_graph_result_bytes() const;
  public:
  void clear_server_graph_result_bytes();
  const ::PROTOBUF_NAMESPACE_ID::Any& server_graph_result_bytes() const;
  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_server_graph_result_bytes();
  ::PROTOBUF_NAMESPACE_ID::Any* mutable_server_graph_result_bytes();
  void set_allocated_server_graph_result_bytes(::PROTOBUF_NAMESPACE_ID::Any* server_graph_result_bytes);
  private:
  const ::PROTOBUF_NAMESPACE_ID::Any& _internal_server_graph_result_bytes() const;
  ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_server_graph_result_bytes();
  public:
  void unsafe_arena_set_allocated_server_graph_result_bytes(
      ::PROTOBUF_NAMESPACE_ID::Any* server_graph_result_bytes);
  ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_server_graph_result_bytes();

  // int32 version = 9;
  void clear_version();
  ::int32_t version() const;
  void set_version(::int32_t value);
  private:
  ::int32_t _internal_version() const;
  void _internal_set_version(::int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.Plan)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::Plan_Phase > phase_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::Metric > metrics_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::OutputMetric > output_metrics_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_tflite_graph_bytes_;
    ::google::internal::federated::plan::CheckpointOp* server_savepoint_;
    ::PROTOBUF_NAMESPACE_ID::Any* server_graph_bytes_;
    ::PROTOBUF_NAMESPACE_ID::Any* client_graph_bytes_;
    ::PROTOBUF_NAMESPACE_ID::Any* tensorflow_config_proto_;
    ::PROTOBUF_NAMESPACE_ID::Any* server_graph_prepare_bytes_;
    ::PROTOBUF_NAMESPACE_ID::Any* server_graph_result_bytes_;
    ::int32_t version_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class ClientOnlyPlan final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.ClientOnlyPlan) */ {
 public:
  inline ClientOnlyPlan() : ClientOnlyPlan(nullptr) {}
  ~ClientOnlyPlan() override;
  explicit PROTOBUF_CONSTEXPR ClientOnlyPlan(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ClientOnlyPlan(const ClientOnlyPlan& from);
  ClientOnlyPlan(ClientOnlyPlan&& from) noexcept
    : ClientOnlyPlan() {
    *this = ::std::move(from);
  }

  inline ClientOnlyPlan& operator=(const ClientOnlyPlan& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline ClientOnlyPlan& operator=(ClientOnlyPlan&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ClientOnlyPlan& default_instance() {
    return *internal_default_instance();
  }
  static inline const ClientOnlyPlan* internal_default_instance() {
    return reinterpret_cast<const ClientOnlyPlan*>(
               &_ClientOnlyPlan_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    57;

  friend void swap(ClientOnlyPlan& a, ClientOnlyPlan& b) {
    a.Swap(&b);
  }
  inline void Swap(ClientOnlyPlan* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ClientOnlyPlan* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ClientOnlyPlan* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ClientOnlyPlan>(arena);
  }
  ClientOnlyPlan* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const ClientOnlyPlan& from);
  void MergeFrom(const ClientOnlyPlan& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ClientOnlyPlan* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.ClientOnlyPlan";
  }
  protected:
  explicit ClientOnlyPlan(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kGraphFieldNumber = 1,
    kTfliteGraphFieldNumber = 5,
    kPhaseFieldNumber = 2,
    kTensorflowConfigProtoFieldNumber = 4,
  };
  // bytes graph = 1;
  void clear_graph();
  const std::string& graph() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_graph(ArgT0&& arg0, ArgT... args);
  std::string* mutable_graph();
  PROTOBUF_NODISCARD std::string* release_graph();
  void set_allocated_graph(std::string* graph);
  private:
  const std::string& _internal_graph() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_graph(const std::string& value);
  std::string* _internal_mutable_graph();
  public:

  // bytes tflite_graph = 5;
  void clear_tflite_graph();
  const std::string& tflite_graph() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_tflite_graph(ArgT0&& arg0, ArgT... args);
  std::string* mutable_tflite_graph();
  PROTOBUF_NODISCARD std::string* release_tflite_graph();
  void set_allocated_tflite_graph(std::string* tflite_graph);
  private:
  const std::string& _internal_tflite_graph() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_tflite_graph(const std::string& value);
  std::string* _internal_mutable_tflite_graph();
  public:

  // .google.internal.federated.plan.ClientPhase phase = 2;
  bool has_phase() const;
  private:
  bool _internal_has_phase() const;
  public:
  void clear_phase();
  const ::google::internal::federated::plan::ClientPhase& phase() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::ClientPhase* release_phase();
  ::google::internal::federated::plan::ClientPhase* mutable_phase();
  void set_allocated_phase(::google::internal::federated::plan::ClientPhase* phase);
  private:
  const ::google::internal::federated::plan::ClientPhase& _internal_phase() const;
  ::google::internal::federated::plan::ClientPhase* _internal_mutable_phase();
  public:
  void unsafe_arena_set_allocated_phase(
      ::google::internal::federated::plan::ClientPhase* phase);
  ::google::internal::federated::plan::ClientPhase* unsafe_arena_release_phase();

  // .google.protobuf.Any tensorflow_config_proto = 4;
  bool has_tensorflow_config_proto() const;
  private:
  bool _internal_has_tensorflow_config_proto() const;
  public:
  void clear_tensorflow_config_proto();
  const ::PROTOBUF_NAMESPACE_ID::Any& tensorflow_config_proto() const;
  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_tensorflow_config_proto();
  ::PROTOBUF_NAMESPACE_ID::Any* mutable_tensorflow_config_proto();
  void set_allocated_tensorflow_config_proto(::PROTOBUF_NAMESPACE_ID::Any* tensorflow_config_proto);
  private:
  const ::PROTOBUF_NAMESPACE_ID::Any& _internal_tensorflow_config_proto() const;
  ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_tensorflow_config_proto();
  public:
  void unsafe_arena_set_allocated_tensorflow_config_proto(
      ::PROTOBUF_NAMESPACE_ID::Any* tensorflow_config_proto);
  ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_tensorflow_config_proto();

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.ClientOnlyPlan)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr graph_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tflite_graph_;
    ::google::internal::federated::plan::ClientPhase* phase_;
    ::PROTOBUF_NAMESPACE_ID::Any* tensorflow_config_proto_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class CrossRoundAggregationExecution final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.CrossRoundAggregationExecution) */ {
 public:
  inline CrossRoundAggregationExecution() : CrossRoundAggregationExecution(nullptr) {}
  ~CrossRoundAggregationExecution() override;
  explicit PROTOBUF_CONSTEXPR CrossRoundAggregationExecution(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CrossRoundAggregationExecution(const CrossRoundAggregationExecution& from);
  CrossRoundAggregationExecution(CrossRoundAggregationExecution&& from) noexcept
    : CrossRoundAggregationExecution() {
    *this = ::std::move(from);
  }

  inline CrossRoundAggregationExecution& operator=(const CrossRoundAggregationExecution& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline CrossRoundAggregationExecution& operator=(CrossRoundAggregationExecution&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const CrossRoundAggregationExecution& default_instance() {
    return *internal_default_instance();
  }
  static inline const CrossRoundAggregationExecution* internal_default_instance() {
    return reinterpret_cast<const CrossRoundAggregationExecution*>(
               &_CrossRoundAggregationExecution_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    58;

  friend void swap(CrossRoundAggregationExecution& a, CrossRoundAggregationExecution& b) {
    a.Swap(&b);
  }
  inline void Swap(CrossRoundAggregationExecution* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CrossRoundAggregationExecution* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CrossRoundAggregationExecution* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CrossRoundAggregationExecution>(arena);
  }
  CrossRoundAggregationExecution* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const CrossRoundAggregationExecution& from);
  void MergeFrom(const CrossRoundAggregationExecution& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(CrossRoundAggregationExecution* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.CrossRoundAggregationExecution";
  }
  protected:
  explicit CrossRoundAggregationExecution(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kMeasurementsFieldNumber = 4,
    kInitOpFieldNumber = 1,
    kMergeOpFieldNumber = 3,
    kReadAggregatedUpdateFieldNumber = 2,
    kCrossRoundAggregationGraphBytesFieldNumber = 5,
    kReadWriteFinalAccumulatorsFieldNumber = 6,
  };
  // repeated .google.internal.federated.plan.Measurement measurements = 4;
  int measurements_size() const;
  private:
  int _internal_measurements_size() const;
  public:
  void clear_measurements();
  ::google::internal::federated::plan::Measurement* mutable_measurements(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::Measurement >*
      mutable_measurements();
  private:
  const ::google::internal::federated::plan::Measurement& _internal_measurements(int index) const;
  ::google::internal::federated::plan::Measurement* _internal_add_measurements();
  public:
  const ::google::internal::federated::plan::Measurement& measurements(int index) const;
  ::google::internal::federated::plan::Measurement* add_measurements();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::Measurement >&
      measurements() const;

  // string init_op = 1;
  void clear_init_op();
  const std::string& init_op() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_init_op(ArgT0&& arg0, ArgT... args);
  std::string* mutable_init_op();
  PROTOBUF_NODISCARD std::string* release_init_op();
  void set_allocated_init_op(std::string* init_op);
  private:
  const std::string& _internal_init_op() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_init_op(const std::string& value);
  std::string* _internal_mutable_init_op();
  public:

  // string merge_op = 3;
  void clear_merge_op();
  const std::string& merge_op() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_merge_op(ArgT0&& arg0, ArgT... args);
  std::string* mutable_merge_op();
  PROTOBUF_NODISCARD std::string* release_merge_op();
  void set_allocated_merge_op(std::string* merge_op);
  private:
  const std::string& _internal_merge_op() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_merge_op(const std::string& value);
  std::string* _internal_mutable_merge_op();
  public:

  // .google.internal.federated.plan.CheckpointOp read_aggregated_update = 2;
  bool has_read_aggregated_update() const;
  private:
  bool _internal_has_read_aggregated_update() const;
  public:
  void clear_read_aggregated_update();
  const ::google::internal::federated::plan::CheckpointOp& read_aggregated_update() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::CheckpointOp* release_read_aggregated_update();
  ::google::internal::federated::plan::CheckpointOp* mutable_read_aggregated_update();
  void set_allocated_read_aggregated_update(::google::internal::federated::plan::CheckpointOp* read_aggregated_update);
  private:
  const ::google::internal::federated::plan::CheckpointOp& _internal_read_aggregated_update() const;
  ::google::internal::federated::plan::CheckpointOp* _internal_mutable_read_aggregated_update();
  public:
  void unsafe_arena_set_allocated_read_aggregated_update(
      ::google::internal::federated::plan::CheckpointOp* read_aggregated_update);
  ::google::internal::federated::plan::CheckpointOp* unsafe_arena_release_read_aggregated_update();

  // .google.protobuf.Any cross_round_aggregation_graph_bytes = 5;
  bool has_cross_round_aggregation_graph_bytes() const;
  private:
  bool _internal_has_cross_round_aggregation_graph_bytes() const;
  public:
  void clear_cross_round_aggregation_graph_bytes();
  const ::PROTOBUF_NAMESPACE_ID::Any& cross_round_aggregation_graph_bytes() const;
  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_cross_round_aggregation_graph_bytes();
  ::PROTOBUF_NAMESPACE_ID::Any* mutable_cross_round_aggregation_graph_bytes();
  void set_allocated_cross_round_aggregation_graph_bytes(::PROTOBUF_NAMESPACE_ID::Any* cross_round_aggregation_graph_bytes);
  private:
  const ::PROTOBUF_NAMESPACE_ID::Any& _internal_cross_round_aggregation_graph_bytes() const;
  ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_cross_round_aggregation_graph_bytes();
  public:
  void unsafe_arena_set_allocated_cross_round_aggregation_graph_bytes(
      ::PROTOBUF_NAMESPACE_ID::Any* cross_round_aggregation_graph_bytes);
  ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_cross_round_aggregation_graph_bytes();

  // .google.internal.federated.plan.CheckpointOp read_write_final_accumulators = 6;
  bool has_read_write_final_accumulators() const;
  private:
  bool _internal_has_read_write_final_accumulators() const;
  public:
  void clear_read_write_final_accumulators();
  const ::google::internal::federated::plan::CheckpointOp& read_write_final_accumulators() const;
  PROTOBUF_NODISCARD ::google::internal::federated::plan::CheckpointOp* release_read_write_final_accumulators();
  ::google::internal::federated::plan::CheckpointOp* mutable_read_write_final_accumulators();
  void set_allocated_read_write_final_accumulators(::google::internal::federated::plan::CheckpointOp* read_write_final_accumulators);
  private:
  const ::google::internal::federated::plan::CheckpointOp& _internal_read_write_final_accumulators() const;
  ::google::internal::federated::plan::CheckpointOp* _internal_mutable_read_write_final_accumulators();
  public:
  void unsafe_arena_set_allocated_read_write_final_accumulators(
      ::google::internal::federated::plan::CheckpointOp* read_write_final_accumulators);
  ::google::internal::federated::plan::CheckpointOp* unsafe_arena_release_read_write_final_accumulators();

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.CrossRoundAggregationExecution)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::Measurement > measurements_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr init_op_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr merge_op_;
    ::google::internal::federated::plan::CheckpointOp* read_aggregated_update_;
    ::PROTOBUF_NAMESPACE_ID::Any* cross_round_aggregation_graph_bytes_;
    ::google::internal::federated::plan::CheckpointOp* read_write_final_accumulators_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// -------------------------------------------------------------------

class Measurement final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:google.internal.federated.plan.Measurement) */ {
 public:
  inline Measurement() : Measurement(nullptr) {}
  ~Measurement() override;
  explicit PROTOBUF_CONSTEXPR Measurement(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Measurement(const Measurement& from);
  Measurement(Measurement&& from) noexcept
    : Measurement() {
    *this = ::std::move(from);
  }

  inline Measurement& operator=(const Measurement& from) {
    if (this == &from) return *this;
    CopyFrom(from);
    return *this;
  }
  inline Measurement& operator=(Measurement&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const Measurement& default_instance() {
    return *internal_default_instance();
  }
  static inline const Measurement* internal_default_instance() {
    return reinterpret_cast<const Measurement*>(
               &_Measurement_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    59;

  friend void swap(Measurement& a, Measurement& b) {
    a.Swap(&b);
  }
  inline void Swap(Measurement* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Measurement* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Measurement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Measurement>(arena);
  }
  Measurement* New() const {
    return New(nullptr);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const Measurement& from);
  void MergeFrom(const Measurement& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::uint8_t* _InternalSerialize(
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Measurement* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "google.internal.federated.plan.Measurement";
  }
  protected:
  explicit Measurement(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  std::string GetTypeName() const final;

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

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

  enum : int {
    kReadOpNameFieldNumber = 1,
    kNameFieldNumber = 2,
    kTffTypeFieldNumber = 4,
  };
  // string read_op_name = 1;
  void clear_read_op_name();
  const std::string& read_op_name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_read_op_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_read_op_name();
  PROTOBUF_NODISCARD std::string* release_read_op_name();
  void set_allocated_read_op_name(std::string* read_op_name);
  private:
  const std::string& _internal_read_op_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_read_op_name(const std::string& value);
  std::string* _internal_mutable_read_op_name();
  public:

  // string name = 2;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // bytes tff_type = 4;
  void clear_tff_type();
  const std::string& tff_type() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_tff_type(ArgT0&& arg0, ArgT... args);
  std::string* mutable_tff_type();
  PROTOBUF_NODISCARD std::string* release_tff_type();
  void set_allocated_tff_type(std::string* tff_type);
  private:
  const std::string& _internal_tff_type() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_tff_type(const std::string& value);
  std::string* _internal_mutable_tff_type();
  public:

  // @@protoc_insertion_point(class_scope:google.internal.federated.plan.Measurement)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr read_op_name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tff_type_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_fcp_2fprotos_2fplan_2eproto;
};
// ===================================================================


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

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// -------------------------------------------------------------------

// CheckpointOp

// .tensorflow.SaverDef saver_def = 1;
inline bool CheckpointOp::_internal_has_saver_def() const {
  return this != internal_default_instance() && _impl_.saver_def_ != nullptr;
}
inline bool CheckpointOp::has_saver_def() const {
  return _internal_has_saver_def();
}
inline const ::tensorflow::SaverDef& CheckpointOp::_internal_saver_def() const {
  const ::tensorflow::SaverDef* p = _impl_.saver_def_;
  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::SaverDef&>(
      ::tensorflow::_SaverDef_default_instance_);
}
inline const ::tensorflow::SaverDef& CheckpointOp::saver_def() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.CheckpointOp.saver_def)
  return _internal_saver_def();
}
inline void CheckpointOp::unsafe_arena_set_allocated_saver_def(
    ::tensorflow::SaverDef* saver_def) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.saver_def_);
  }
  _impl_.saver_def_ = saver_def;
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.CheckpointOp.saver_def)
}
inline ::tensorflow::SaverDef* CheckpointOp::release_saver_def() {

  ::tensorflow::SaverDef* temp = _impl_.saver_def_;
  _impl_.saver_def_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::tensorflow::SaverDef* CheckpointOp::unsafe_arena_release_saver_def() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.CheckpointOp.saver_def)

  ::tensorflow::SaverDef* temp = _impl_.saver_def_;
  _impl_.saver_def_ = nullptr;
  return temp;
}
inline ::tensorflow::SaverDef* CheckpointOp::_internal_mutable_saver_def() {

  if (_impl_.saver_def_ == nullptr) {
    auto* p = CreateMaybeMessage<::tensorflow::SaverDef>(GetArenaForAllocation());
    _impl_.saver_def_ = p;
  }
  return _impl_.saver_def_;
}
inline ::tensorflow::SaverDef* CheckpointOp::mutable_saver_def() {
  ::tensorflow::SaverDef* _msg = _internal_mutable_saver_def();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.CheckpointOp.saver_def)
  return _msg;
}
inline void CheckpointOp::set_allocated_saver_def(::tensorflow::SaverDef* saver_def) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.saver_def_);
  }
  if (saver_def) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(saver_def));
    if (message_arena != submessage_arena) {
      saver_def = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, saver_def, submessage_arena);
    }

  } else {

  }
  _impl_.saver_def_ = saver_def;
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.CheckpointOp.saver_def)
}

// string before_restore_op = 2;
inline void CheckpointOp::clear_before_restore_op() {
  _impl_.before_restore_op_.ClearToEmpty();
}
inline const std::string& CheckpointOp::before_restore_op() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.CheckpointOp.before_restore_op)
  return _internal_before_restore_op();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CheckpointOp::set_before_restore_op(ArgT0&& arg0, ArgT... args) {

 _impl_.before_restore_op_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.CheckpointOp.before_restore_op)
}
inline std::string* CheckpointOp::mutable_before_restore_op() {
  std::string* _s = _internal_mutable_before_restore_op();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.CheckpointOp.before_restore_op)
  return _s;
}
inline const std::string& CheckpointOp::_internal_before_restore_op() const {
  return _impl_.before_restore_op_.Get();
}
inline void CheckpointOp::_internal_set_before_restore_op(const std::string& value) {

  _impl_.before_restore_op_.Set(value, GetArenaForAllocation());
}
inline std::string* CheckpointOp::_internal_mutable_before_restore_op() {

  return _impl_.before_restore_op_.Mutable(GetArenaForAllocation());
}
inline std::string* CheckpointOp::release_before_restore_op() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.CheckpointOp.before_restore_op)
  return _impl_.before_restore_op_.Release();
}
inline void CheckpointOp::set_allocated_before_restore_op(std::string* before_restore_op) {
  _impl_.before_restore_op_.SetAllocated(before_restore_op, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.before_restore_op_.IsDefault()) {
    _impl_.before_restore_op_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.CheckpointOp.before_restore_op)
}

// string after_restore_op = 3;
inline void CheckpointOp::clear_after_restore_op() {
  _impl_.after_restore_op_.ClearToEmpty();
}
inline const std::string& CheckpointOp::after_restore_op() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.CheckpointOp.after_restore_op)
  return _internal_after_restore_op();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CheckpointOp::set_after_restore_op(ArgT0&& arg0, ArgT... args) {

 _impl_.after_restore_op_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.CheckpointOp.after_restore_op)
}
inline std::string* CheckpointOp::mutable_after_restore_op() {
  std::string* _s = _internal_mutable_after_restore_op();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.CheckpointOp.after_restore_op)
  return _s;
}
inline const std::string& CheckpointOp::_internal_after_restore_op() const {
  return _impl_.after_restore_op_.Get();
}
inline void CheckpointOp::_internal_set_after_restore_op(const std::string& value) {

  _impl_.after_restore_op_.Set(value, GetArenaForAllocation());
}
inline std::string* CheckpointOp::_internal_mutable_after_restore_op() {

  return _impl_.after_restore_op_.Mutable(GetArenaForAllocation());
}
inline std::string* CheckpointOp::release_after_restore_op() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.CheckpointOp.after_restore_op)
  return _impl_.after_restore_op_.Release();
}
inline void CheckpointOp::set_allocated_after_restore_op(std::string* after_restore_op) {
  _impl_.after_restore_op_.SetAllocated(after_restore_op, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.after_restore_op_.IsDefault()) {
    _impl_.after_restore_op_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.CheckpointOp.after_restore_op)
}

// string before_save_op = 4;
inline void CheckpointOp::clear_before_save_op() {
  _impl_.before_save_op_.ClearToEmpty();
}
inline const std::string& CheckpointOp::before_save_op() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.CheckpointOp.before_save_op)
  return _internal_before_save_op();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CheckpointOp::set_before_save_op(ArgT0&& arg0, ArgT... args) {

 _impl_.before_save_op_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.CheckpointOp.before_save_op)
}
inline std::string* CheckpointOp::mutable_before_save_op() {
  std::string* _s = _internal_mutable_before_save_op();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.CheckpointOp.before_save_op)
  return _s;
}
inline const std::string& CheckpointOp::_internal_before_save_op() const {
  return _impl_.before_save_op_.Get();
}
inline void CheckpointOp::_internal_set_before_save_op(const std::string& value) {

  _impl_.before_save_op_.Set(value, GetArenaForAllocation());
}
inline std::string* CheckpointOp::_internal_mutable_before_save_op() {

  return _impl_.before_save_op_.Mutable(GetArenaForAllocation());
}
inline std::string* CheckpointOp::release_before_save_op() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.CheckpointOp.before_save_op)
  return _impl_.before_save_op_.Release();
}
inline void CheckpointOp::set_allocated_before_save_op(std::string* before_save_op) {
  _impl_.before_save_op_.SetAllocated(before_save_op, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.before_save_op_.IsDefault()) {
    _impl_.before_save_op_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.CheckpointOp.before_save_op)
}

// string after_save_op = 5;
inline void CheckpointOp::clear_after_save_op() {
  _impl_.after_save_op_.ClearToEmpty();
}
inline const std::string& CheckpointOp::after_save_op() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.CheckpointOp.after_save_op)
  return _internal_after_save_op();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CheckpointOp::set_after_save_op(ArgT0&& arg0, ArgT... args) {

 _impl_.after_save_op_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.CheckpointOp.after_save_op)
}
inline std::string* CheckpointOp::mutable_after_save_op() {
  std::string* _s = _internal_mutable_after_save_op();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.CheckpointOp.after_save_op)
  return _s;
}
inline const std::string& CheckpointOp::_internal_after_save_op() const {
  return _impl_.after_save_op_.Get();
}
inline void CheckpointOp::_internal_set_after_save_op(const std::string& value) {

  _impl_.after_save_op_.Set(value, GetArenaForAllocation());
}
inline std::string* CheckpointOp::_internal_mutable_after_save_op() {

  return _impl_.after_save_op_.Mutable(GetArenaForAllocation());
}
inline std::string* CheckpointOp::release_after_save_op() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.CheckpointOp.after_save_op)
  return _impl_.after_save_op_.Release();
}
inline void CheckpointOp::set_allocated_after_save_op(std::string* after_save_op) {
  _impl_.after_save_op_.SetAllocated(after_save_op, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.after_save_op_.IsDefault()) {
    _impl_.after_save_op_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.CheckpointOp.after_save_op)
}

// map<string, .google.internal.federated.plan.SideChannel> side_channel_tensors = 6;
inline int CheckpointOp::_internal_side_channel_tensors_size() const {
  return _impl_.side_channel_tensors_.size();
}
inline int CheckpointOp::side_channel_tensors_size() const {
  return _internal_side_channel_tensors_size();
}
inline void CheckpointOp::clear_side_channel_tensors() {
  _impl_.side_channel_tensors_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::SideChannel >&
CheckpointOp::_internal_side_channel_tensors() const {
  return _impl_.side_channel_tensors_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::SideChannel >&
CheckpointOp::side_channel_tensors() const {
  // @@protoc_insertion_point(field_map:google.internal.federated.plan.CheckpointOp.side_channel_tensors)
  return _internal_side_channel_tensors();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::SideChannel >*
CheckpointOp::_internal_mutable_side_channel_tensors() {
  return _impl_.side_channel_tensors_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::SideChannel >*
CheckpointOp::mutable_side_channel_tensors() {
  // @@protoc_insertion_point(field_mutable_map:google.internal.federated.plan.CheckpointOp.side_channel_tensors)
  return _internal_mutable_side_channel_tensors();
}

// string session_token_tensor_name = 7;
inline void CheckpointOp::clear_session_token_tensor_name() {
  _impl_.session_token_tensor_name_.ClearToEmpty();
}
inline const std::string& CheckpointOp::session_token_tensor_name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.CheckpointOp.session_token_tensor_name)
  return _internal_session_token_tensor_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CheckpointOp::set_session_token_tensor_name(ArgT0&& arg0, ArgT... args) {

 _impl_.session_token_tensor_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.CheckpointOp.session_token_tensor_name)
}
inline std::string* CheckpointOp::mutable_session_token_tensor_name() {
  std::string* _s = _internal_mutable_session_token_tensor_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.CheckpointOp.session_token_tensor_name)
  return _s;
}
inline const std::string& CheckpointOp::_internal_session_token_tensor_name() const {
  return _impl_.session_token_tensor_name_.Get();
}
inline void CheckpointOp::_internal_set_session_token_tensor_name(const std::string& value) {

  _impl_.session_token_tensor_name_.Set(value, GetArenaForAllocation());
}
inline std::string* CheckpointOp::_internal_mutable_session_token_tensor_name() {

  return _impl_.session_token_tensor_name_.Mutable(GetArenaForAllocation());
}
inline std::string* CheckpointOp::release_session_token_tensor_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.CheckpointOp.session_token_tensor_name)
  return _impl_.session_token_tensor_name_.Release();
}
inline void CheckpointOp::set_allocated_session_token_tensor_name(std::string* session_token_tensor_name) {
  _impl_.session_token_tensor_name_.SetAllocated(session_token_tensor_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.session_token_tensor_name_.IsDefault()) {
    _impl_.session_token_tensor_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.CheckpointOp.session_token_tensor_name)
}

// -------------------------------------------------------------------

// SideChannel_SecureAggregand_Dimension

// int64 size = 1;
inline void SideChannel_SecureAggregand_Dimension::clear_size() {
  _impl_.size_ = ::int64_t{0};
}
inline ::int64_t SideChannel_SecureAggregand_Dimension::_internal_size() const {
  return _impl_.size_;
}
inline ::int64_t SideChannel_SecureAggregand_Dimension::size() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.SideChannel.SecureAggregand.Dimension.size)
  return _internal_size();
}
inline void SideChannel_SecureAggregand_Dimension::_internal_set_size(::int64_t value) {

  _impl_.size_ = value;
}
inline void SideChannel_SecureAggregand_Dimension::set_size(::int64_t value) {
  _internal_set_size(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.SideChannel.SecureAggregand.Dimension.size)
}

// -------------------------------------------------------------------

// SideChannel_SecureAggregand_FixedModulus

// uint64 modulus = 1;
inline void SideChannel_SecureAggregand_FixedModulus::clear_modulus() {
  _impl_.modulus_ = ::uint64_t{0u};
}
inline ::uint64_t SideChannel_SecureAggregand_FixedModulus::_internal_modulus() const {
  return _impl_.modulus_;
}
inline ::uint64_t SideChannel_SecureAggregand_FixedModulus::modulus() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.SideChannel.SecureAggregand.FixedModulus.modulus)
  return _internal_modulus();
}
inline void SideChannel_SecureAggregand_FixedModulus::_internal_set_modulus(::uint64_t value) {

  _impl_.modulus_ = value;
}
inline void SideChannel_SecureAggregand_FixedModulus::set_modulus(::uint64_t value) {
  _internal_set_modulus(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.SideChannel.SecureAggregand.FixedModulus.modulus)
}

// -------------------------------------------------------------------

// SideChannel_SecureAggregand_ModulusTimesShardSize

// uint64 base_modulus = 1;
inline void SideChannel_SecureAggregand_ModulusTimesShardSize::clear_base_modulus() {
  _impl_.base_modulus_ = ::uint64_t{0u};
}
inline ::uint64_t SideChannel_SecureAggregand_ModulusTimesShardSize::_internal_base_modulus() const {
  return _impl_.base_modulus_;
}
inline ::uint64_t SideChannel_SecureAggregand_ModulusTimesShardSize::base_modulus() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.SideChannel.SecureAggregand.ModulusTimesShardSize.base_modulus)
  return _internal_base_modulus();
}
inline void SideChannel_SecureAggregand_ModulusTimesShardSize::_internal_set_base_modulus(::uint64_t value) {

  _impl_.base_modulus_ = value;
}
inline void SideChannel_SecureAggregand_ModulusTimesShardSize::set_base_modulus(::uint64_t value) {
  _internal_set_base_modulus(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.SideChannel.SecureAggregand.ModulusTimesShardSize.base_modulus)
}

// -------------------------------------------------------------------

// SideChannel_SecureAggregand

// repeated .google.internal.federated.plan.SideChannel.SecureAggregand.Dimension dimension = 3;
inline int SideChannel_SecureAggregand::_internal_dimension_size() const {
  return _impl_.dimension_.size();
}
inline int SideChannel_SecureAggregand::dimension_size() const {
  return _internal_dimension_size();
}
inline void SideChannel_SecureAggregand::clear_dimension() {
  _impl_.dimension_.Clear();
}
inline ::google::internal::federated::plan::SideChannel_SecureAggregand_Dimension* SideChannel_SecureAggregand::mutable_dimension(int index) {
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.SideChannel.SecureAggregand.dimension)
  return _impl_.dimension_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::SideChannel_SecureAggregand_Dimension >*
SideChannel_SecureAggregand::mutable_dimension() {
  // @@protoc_insertion_point(field_mutable_list:google.internal.federated.plan.SideChannel.SecureAggregand.dimension)
  return &_impl_.dimension_;
}
inline const ::google::internal::federated::plan::SideChannel_SecureAggregand_Dimension& SideChannel_SecureAggregand::_internal_dimension(int index) const {
  return _impl_.dimension_.Get(index);
}
inline const ::google::internal::federated::plan::SideChannel_SecureAggregand_Dimension& SideChannel_SecureAggregand::dimension(int index) const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.SideChannel.SecureAggregand.dimension)
  return _internal_dimension(index);
}
inline ::google::internal::federated::plan::SideChannel_SecureAggregand_Dimension* SideChannel_SecureAggregand::_internal_add_dimension() {
  return _impl_.dimension_.Add();
}
inline ::google::internal::federated::plan::SideChannel_SecureAggregand_Dimension* SideChannel_SecureAggregand::add_dimension() {
  ::google::internal::federated::plan::SideChannel_SecureAggregand_Dimension* _add = _internal_add_dimension();
  // @@protoc_insertion_point(field_add:google.internal.federated.plan.SideChannel.SecureAggregand.dimension)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::SideChannel_SecureAggregand_Dimension >&
SideChannel_SecureAggregand::dimension() const {
  // @@protoc_insertion_point(field_list:google.internal.federated.plan.SideChannel.SecureAggregand.dimension)
  return _impl_.dimension_;
}

// .tensorflow.DataType dtype = 4;
inline void SideChannel_SecureAggregand::clear_dtype() {
  _impl_.dtype_ = 0;
}
inline ::tensorflow::DataType SideChannel_SecureAggregand::_internal_dtype() const {
  return static_cast< ::tensorflow::DataType >(_impl_.dtype_);
}
inline ::tensorflow::DataType SideChannel_SecureAggregand::dtype() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.SideChannel.SecureAggregand.dtype)
  return _internal_dtype();
}
inline void SideChannel_SecureAggregand::_internal_set_dtype(::tensorflow::DataType value) {

  _impl_.dtype_ = value;
}
inline void SideChannel_SecureAggregand::set_dtype(::tensorflow::DataType value) {
  _internal_set_dtype(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.SideChannel.SecureAggregand.dtype)
}

// int32 quantized_input_bitwidth = 2 [deprecated = true];
inline bool SideChannel_SecureAggregand::_internal_has_quantized_input_bitwidth() const {
  return modulus_scheme_case() == kQuantizedInputBitwidth;
}
inline bool SideChannel_SecureAggregand::has_quantized_input_bitwidth() const {
  return _internal_has_quantized_input_bitwidth();
}
inline void SideChannel_SecureAggregand::set_has_quantized_input_bitwidth() {
  _impl_._oneof_case_[0] = kQuantizedInputBitwidth;
}
inline void SideChannel_SecureAggregand::clear_quantized_input_bitwidth() {
  if (_internal_has_quantized_input_bitwidth()) {
    _impl_.modulus_scheme_.quantized_input_bitwidth_ = 0;
    clear_has_modulus_scheme();
  }
}
inline ::int32_t SideChannel_SecureAggregand::_internal_quantized_input_bitwidth() const {
  if (_internal_has_quantized_input_bitwidth()) {
    return _impl_.modulus_scheme_.quantized_input_bitwidth_;
  }
  return 0;
}
inline void SideChannel_SecureAggregand::_internal_set_quantized_input_bitwidth(::int32_t value) {
  if (!_internal_has_quantized_input_bitwidth()) {
    clear_modulus_scheme();
    set_has_quantized_input_bitwidth();
  }
  _impl_.modulus_scheme_.quantized_input_bitwidth_ = value;
}
inline ::int32_t SideChannel_SecureAggregand::quantized_input_bitwidth() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.SideChannel.SecureAggregand.quantized_input_bitwidth)
  return _internal_quantized_input_bitwidth();
}
inline void SideChannel_SecureAggregand::set_quantized_input_bitwidth(::int32_t value) {
  _internal_set_quantized_input_bitwidth(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.SideChannel.SecureAggregand.quantized_input_bitwidth)
}

// .google.internal.federated.plan.SideChannel.SecureAggregand.FixedModulus fixed_modulus = 5;
inline bool SideChannel_SecureAggregand::_internal_has_fixed_modulus() const {
  return modulus_scheme_case() == kFixedModulus;
}
inline bool SideChannel_SecureAggregand::has_fixed_modulus() const {
  return _internal_has_fixed_modulus();
}
inline void SideChannel_SecureAggregand::set_has_fixed_modulus() {
  _impl_._oneof_case_[0] = kFixedModulus;
}
inline void SideChannel_SecureAggregand::clear_fixed_modulus() {
  if (_internal_has_fixed_modulus()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.modulus_scheme_.fixed_modulus_;
    }
    clear_has_modulus_scheme();
  }
}
inline ::google::internal::federated::plan::SideChannel_SecureAggregand_FixedModulus* SideChannel_SecureAggregand::release_fixed_modulus() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.SideChannel.SecureAggregand.fixed_modulus)
  if (_internal_has_fixed_modulus()) {
    clear_has_modulus_scheme();
    ::google::internal::federated::plan::SideChannel_SecureAggregand_FixedModulus* temp = _impl_.modulus_scheme_.fixed_modulus_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.modulus_scheme_.fixed_modulus_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::google::internal::federated::plan::SideChannel_SecureAggregand_FixedModulus& SideChannel_SecureAggregand::_internal_fixed_modulus() const {
  return _internal_has_fixed_modulus()
      ? *_impl_.modulus_scheme_.fixed_modulus_
      : reinterpret_cast< ::google::internal::federated::plan::SideChannel_SecureAggregand_FixedModulus&>(::google::internal::federated::plan::_SideChannel_SecureAggregand_FixedModulus_default_instance_);
}
inline const ::google::internal::federated::plan::SideChannel_SecureAggregand_FixedModulus& SideChannel_SecureAggregand::fixed_modulus() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.SideChannel.SecureAggregand.fixed_modulus)
  return _internal_fixed_modulus();
}
inline ::google::internal::federated::plan::SideChannel_SecureAggregand_FixedModulus* SideChannel_SecureAggregand::unsafe_arena_release_fixed_modulus() {
  // @@protoc_insertion_point(field_unsafe_arena_release:google.internal.federated.plan.SideChannel.SecureAggregand.fixed_modulus)
  if (_internal_has_fixed_modulus()) {
    clear_has_modulus_scheme();
    ::google::internal::federated::plan::SideChannel_SecureAggregand_FixedModulus* temp = _impl_.modulus_scheme_.fixed_modulus_;
    _impl_.modulus_scheme_.fixed_modulus_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void SideChannel_SecureAggregand::unsafe_arena_set_allocated_fixed_modulus(::google::internal::federated::plan::SideChannel_SecureAggregand_FixedModulus* fixed_modulus) {
  clear_modulus_scheme();
  if (fixed_modulus) {
    set_has_fixed_modulus();
    _impl_.modulus_scheme_.fixed_modulus_ = fixed_modulus;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.SideChannel.SecureAggregand.fixed_modulus)
}
inline ::google::internal::federated::plan::SideChannel_SecureAggregand_FixedModulus* SideChannel_SecureAggregand::_internal_mutable_fixed_modulus() {
  if (!_internal_has_fixed_modulus()) {
    clear_modulus_scheme();
    set_has_fixed_modulus();
    _impl_.modulus_scheme_.fixed_modulus_ = CreateMaybeMessage< ::google::internal::federated::plan::SideChannel_SecureAggregand_FixedModulus >(GetArenaForAllocation());
  }
  return _impl_.modulus_scheme_.fixed_modulus_;
}
inline ::google::internal::federated::plan::SideChannel_SecureAggregand_FixedModulus* SideChannel_SecureAggregand::mutable_fixed_modulus() {
  ::google::internal::federated::plan::SideChannel_SecureAggregand_FixedModulus* _msg = _internal_mutable_fixed_modulus();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.SideChannel.SecureAggregand.fixed_modulus)
  return _msg;
}

// .google.internal.federated.plan.SideChannel.SecureAggregand.ModulusTimesShardSize modulus_times_shard_size = 6;
inline bool SideChannel_SecureAggregand::_internal_has_modulus_times_shard_size() const {
  return modulus_scheme_case() == kModulusTimesShardSize;
}
inline bool SideChannel_SecureAggregand::has_modulus_times_shard_size() const {
  return _internal_has_modulus_times_shard_size();
}
inline void SideChannel_SecureAggregand::set_has_modulus_times_shard_size() {
  _impl_._oneof_case_[0] = kModulusTimesShardSize;
}
inline void SideChannel_SecureAggregand::clear_modulus_times_shard_size() {
  if (_internal_has_modulus_times_shard_size()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.modulus_scheme_.modulus_times_shard_size_;
    }
    clear_has_modulus_scheme();
  }
}
inline ::google::internal::federated::plan::SideChannel_SecureAggregand_ModulusTimesShardSize* SideChannel_SecureAggregand::release_modulus_times_shard_size() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.SideChannel.SecureAggregand.modulus_times_shard_size)
  if (_internal_has_modulus_times_shard_size()) {
    clear_has_modulus_scheme();
    ::google::internal::federated::plan::SideChannel_SecureAggregand_ModulusTimesShardSize* temp = _impl_.modulus_scheme_.modulus_times_shard_size_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.modulus_scheme_.modulus_times_shard_size_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::google::internal::federated::plan::SideChannel_SecureAggregand_ModulusTimesShardSize& SideChannel_SecureAggregand::_internal_modulus_times_shard_size() const {
  return _internal_has_modulus_times_shard_size()
      ? *_impl_.modulus_scheme_.modulus_times_shard_size_
      : reinterpret_cast< ::google::internal::federated::plan::SideChannel_SecureAggregand_ModulusTimesShardSize&>(::google::internal::federated::plan::_SideChannel_SecureAggregand_ModulusTimesShardSize_default_instance_);
}
inline const ::google::internal::federated::plan::SideChannel_SecureAggregand_ModulusTimesShardSize& SideChannel_SecureAggregand::modulus_times_shard_size() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.SideChannel.SecureAggregand.modulus_times_shard_size)
  return _internal_modulus_times_shard_size();
}
inline ::google::internal::federated::plan::SideChannel_SecureAggregand_ModulusTimesShardSize* SideChannel_SecureAggregand::unsafe_arena_release_modulus_times_shard_size() {
  // @@protoc_insertion_point(field_unsafe_arena_release:google.internal.federated.plan.SideChannel.SecureAggregand.modulus_times_shard_size)
  if (_internal_has_modulus_times_shard_size()) {
    clear_has_modulus_scheme();
    ::google::internal::federated::plan::SideChannel_SecureAggregand_ModulusTimesShardSize* temp = _impl_.modulus_scheme_.modulus_times_shard_size_;
    _impl_.modulus_scheme_.modulus_times_shard_size_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void SideChannel_SecureAggregand::unsafe_arena_set_allocated_modulus_times_shard_size(::google::internal::federated::plan::SideChannel_SecureAggregand_ModulusTimesShardSize* modulus_times_shard_size) {
  clear_modulus_scheme();
  if (modulus_times_shard_size) {
    set_has_modulus_times_shard_size();
    _impl_.modulus_scheme_.modulus_times_shard_size_ = modulus_times_shard_size;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.SideChannel.SecureAggregand.modulus_times_shard_size)
}
inline ::google::internal::federated::plan::SideChannel_SecureAggregand_ModulusTimesShardSize* SideChannel_SecureAggregand::_internal_mutable_modulus_times_shard_size() {
  if (!_internal_has_modulus_times_shard_size()) {
    clear_modulus_scheme();
    set_has_modulus_times_shard_size();
    _impl_.modulus_scheme_.modulus_times_shard_size_ = CreateMaybeMessage< ::google::internal::federated::plan::SideChannel_SecureAggregand_ModulusTimesShardSize >(GetArenaForAllocation());
  }
  return _impl_.modulus_scheme_.modulus_times_shard_size_;
}
inline ::google::internal::federated::plan::SideChannel_SecureAggregand_ModulusTimesShardSize* SideChannel_SecureAggregand::mutable_modulus_times_shard_size() {
  ::google::internal::federated::plan::SideChannel_SecureAggregand_ModulusTimesShardSize* _msg = _internal_mutable_modulus_times_shard_size();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.SideChannel.SecureAggregand.modulus_times_shard_size)
  return _msg;
}

inline bool SideChannel_SecureAggregand::has_modulus_scheme() const {
  return modulus_scheme_case() != MODULUS_SCHEME_NOT_SET;
}
inline void SideChannel_SecureAggregand::clear_has_modulus_scheme() {
  _impl_._oneof_case_[0] = MODULUS_SCHEME_NOT_SET;
}
inline SideChannel_SecureAggregand::ModulusSchemeCase SideChannel_SecureAggregand::modulus_scheme_case() const {
  return SideChannel_SecureAggregand::ModulusSchemeCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// SideChannel

// .google.internal.federated.plan.SideChannel.SecureAggregand secure_aggregand = 1;
inline bool SideChannel::_internal_has_secure_aggregand() const {
  return type_case() == kSecureAggregand;
}
inline bool SideChannel::has_secure_aggregand() const {
  return _internal_has_secure_aggregand();
}
inline void SideChannel::set_has_secure_aggregand() {
  _impl_._oneof_case_[0] = kSecureAggregand;
}
inline void SideChannel::clear_secure_aggregand() {
  if (_internal_has_secure_aggregand()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.type_.secure_aggregand_;
    }
    clear_has_type();
  }
}
inline ::google::internal::federated::plan::SideChannel_SecureAggregand* SideChannel::release_secure_aggregand() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.SideChannel.secure_aggregand)
  if (_internal_has_secure_aggregand()) {
    clear_has_type();
    ::google::internal::federated::plan::SideChannel_SecureAggregand* temp = _impl_.type_.secure_aggregand_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.type_.secure_aggregand_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::google::internal::federated::plan::SideChannel_SecureAggregand& SideChannel::_internal_secure_aggregand() const {
  return _internal_has_secure_aggregand()
      ? *_impl_.type_.secure_aggregand_
      : reinterpret_cast< ::google::internal::federated::plan::SideChannel_SecureAggregand&>(::google::internal::federated::plan::_SideChannel_SecureAggregand_default_instance_);
}
inline const ::google::internal::federated::plan::SideChannel_SecureAggregand& SideChannel::secure_aggregand() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.SideChannel.secure_aggregand)
  return _internal_secure_aggregand();
}
inline ::google::internal::federated::plan::SideChannel_SecureAggregand* SideChannel::unsafe_arena_release_secure_aggregand() {
  // @@protoc_insertion_point(field_unsafe_arena_release:google.internal.federated.plan.SideChannel.secure_aggregand)
  if (_internal_has_secure_aggregand()) {
    clear_has_type();
    ::google::internal::federated::plan::SideChannel_SecureAggregand* temp = _impl_.type_.secure_aggregand_;
    _impl_.type_.secure_aggregand_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void SideChannel::unsafe_arena_set_allocated_secure_aggregand(::google::internal::federated::plan::SideChannel_SecureAggregand* secure_aggregand) {
  clear_type();
  if (secure_aggregand) {
    set_has_secure_aggregand();
    _impl_.type_.secure_aggregand_ = secure_aggregand;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.SideChannel.secure_aggregand)
}
inline ::google::internal::federated::plan::SideChannel_SecureAggregand* SideChannel::_internal_mutable_secure_aggregand() {
  if (!_internal_has_secure_aggregand()) {
    clear_type();
    set_has_secure_aggregand();
    _impl_.type_.secure_aggregand_ = CreateMaybeMessage< ::google::internal::federated::plan::SideChannel_SecureAggregand >(GetArenaForAllocation());
  }
  return _impl_.type_.secure_aggregand_;
}
inline ::google::internal::federated::plan::SideChannel_SecureAggregand* SideChannel::mutable_secure_aggregand() {
  ::google::internal::federated::plan::SideChannel_SecureAggregand* _msg = _internal_mutable_secure_aggregand();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.SideChannel.secure_aggregand)
  return _msg;
}

// string restore_name = 2;
inline void SideChannel::clear_restore_name() {
  _impl_.restore_name_.ClearToEmpty();
}
inline const std::string& SideChannel::restore_name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.SideChannel.restore_name)
  return _internal_restore_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SideChannel::set_restore_name(ArgT0&& arg0, ArgT... args) {

 _impl_.restore_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.SideChannel.restore_name)
}
inline std::string* SideChannel::mutable_restore_name() {
  std::string* _s = _internal_mutable_restore_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.SideChannel.restore_name)
  return _s;
}
inline const std::string& SideChannel::_internal_restore_name() const {
  return _impl_.restore_name_.Get();
}
inline void SideChannel::_internal_set_restore_name(const std::string& value) {

  _impl_.restore_name_.Set(value, GetArenaForAllocation());
}
inline std::string* SideChannel::_internal_mutable_restore_name() {

  return _impl_.restore_name_.Mutable(GetArenaForAllocation());
}
inline std::string* SideChannel::release_restore_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.SideChannel.restore_name)
  return _impl_.restore_name_.Release();
}
inline void SideChannel::set_allocated_restore_name(std::string* restore_name) {
  _impl_.restore_name_.SetAllocated(restore_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.restore_name_.IsDefault()) {
    _impl_.restore_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.SideChannel.restore_name)
}

inline bool SideChannel::has_type() const {
  return type_case() != TYPE_NOT_SET;
}
inline void SideChannel::clear_has_type() {
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}
inline SideChannel::TypeCase SideChannel::type_case() const {
  return SideChannel::TypeCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// Metric

// string variable_name = 1;
inline void Metric::clear_variable_name() {
  _impl_.variable_name_.ClearToEmpty();
}
inline const std::string& Metric::variable_name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.Metric.variable_name)
  return _internal_variable_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Metric::set_variable_name(ArgT0&& arg0, ArgT... args) {

 _impl_.variable_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.Metric.variable_name)
}
inline std::string* Metric::mutable_variable_name() {
  std::string* _s = _internal_mutable_variable_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.Metric.variable_name)
  return _s;
}
inline const std::string& Metric::_internal_variable_name() const {
  return _impl_.variable_name_.Get();
}
inline void Metric::_internal_set_variable_name(const std::string& value) {

  _impl_.variable_name_.Set(value, GetArenaForAllocation());
}
inline std::string* Metric::_internal_mutable_variable_name() {

  return _impl_.variable_name_.Mutable(GetArenaForAllocation());
}
inline std::string* Metric::release_variable_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.Metric.variable_name)
  return _impl_.variable_name_.Release();
}
inline void Metric::set_allocated_variable_name(std::string* variable_name) {
  _impl_.variable_name_.SetAllocated(variable_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.variable_name_.IsDefault()) {
    _impl_.variable_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.Metric.variable_name)
}

// string stat_name = 2;
inline void Metric::clear_stat_name() {
  _impl_.stat_name_.ClearToEmpty();
}
inline const std::string& Metric::stat_name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.Metric.stat_name)
  return _internal_stat_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Metric::set_stat_name(ArgT0&& arg0, ArgT... args) {

 _impl_.stat_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.Metric.stat_name)
}
inline std::string* Metric::mutable_stat_name() {
  std::string* _s = _internal_mutable_stat_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.Metric.stat_name)
  return _s;
}
inline const std::string& Metric::_internal_stat_name() const {
  return _impl_.stat_name_.Get();
}
inline void Metric::_internal_set_stat_name(const std::string& value) {

  _impl_.stat_name_.Set(value, GetArenaForAllocation());
}
inline std::string* Metric::_internal_mutable_stat_name() {

  return _impl_.stat_name_.Mutable(GetArenaForAllocation());
}
inline std::string* Metric::release_stat_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.Metric.stat_name)
  return _impl_.stat_name_.Release();
}
inline void Metric::set_allocated_stat_name(std::string* stat_name) {
  _impl_.stat_name_.SetAllocated(stat_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.stat_name_.IsDefault()) {
    _impl_.stat_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.Metric.stat_name)
}

// string weight_name = 3;
inline void Metric::clear_weight_name() {
  _impl_.weight_name_.ClearToEmpty();
}
inline const std::string& Metric::weight_name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.Metric.weight_name)
  return _internal_weight_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Metric::set_weight_name(ArgT0&& arg0, ArgT... args) {

 _impl_.weight_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.Metric.weight_name)
}
inline std::string* Metric::mutable_weight_name() {
  std::string* _s = _internal_mutable_weight_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.Metric.weight_name)
  return _s;
}
inline const std::string& Metric::_internal_weight_name() const {
  return _impl_.weight_name_.Get();
}
inline void Metric::_internal_set_weight_name(const std::string& value) {

  _impl_.weight_name_.Set(value, GetArenaForAllocation());
}
inline std::string* Metric::_internal_mutable_weight_name() {

  return _impl_.weight_name_.Mutable(GetArenaForAllocation());
}
inline std::string* Metric::release_weight_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.Metric.weight_name)
  return _impl_.weight_name_.Release();
}
inline void Metric::set_allocated_weight_name(std::string* weight_name) {
  _impl_.weight_name_.SetAllocated(weight_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.weight_name_.IsDefault()) {
    _impl_.weight_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.Metric.weight_name)
}

// -------------------------------------------------------------------

// OutputMetric

// string name = 1;
inline void OutputMetric::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& OutputMetric::name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.OutputMetric.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void OutputMetric::set_name(ArgT0&& arg0, ArgT... args) {

 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.OutputMetric.name)
}
inline std::string* OutputMetric::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.OutputMetric.name)
  return _s;
}
inline const std::string& OutputMetric::_internal_name() const {
  return _impl_.name_.Get();
}
inline void OutputMetric::_internal_set_name(const std::string& value) {

  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* OutputMetric::_internal_mutable_name() {

  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* OutputMetric::release_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.OutputMetric.name)
  return _impl_.name_.Release();
}
inline void OutputMetric::set_allocated_name(std::string* name) {
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.OutputMetric.name)
}

// .google.internal.federated.plan.SumOptions sum = 2;
inline bool OutputMetric::_internal_has_sum() const {
  return value_source_case() == kSum;
}
inline bool OutputMetric::has_sum() const {
  return _internal_has_sum();
}
inline void OutputMetric::set_has_sum() {
  _impl_._oneof_case_[0] = kSum;
}
inline void OutputMetric::clear_sum() {
  if (_internal_has_sum()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.value_source_.sum_;
    }
    clear_has_value_source();
  }
}
inline ::google::internal::federated::plan::SumOptions* OutputMetric::release_sum() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.OutputMetric.sum)
  if (_internal_has_sum()) {
    clear_has_value_source();
    ::google::internal::federated::plan::SumOptions* temp = _impl_.value_source_.sum_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_source_.sum_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::google::internal::federated::plan::SumOptions& OutputMetric::_internal_sum() const {
  return _internal_has_sum()
      ? *_impl_.value_source_.sum_
      : reinterpret_cast< ::google::internal::federated::plan::SumOptions&>(::google::internal::federated::plan::_SumOptions_default_instance_);
}
inline const ::google::internal::federated::plan::SumOptions& OutputMetric::sum() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.OutputMetric.sum)
  return _internal_sum();
}
inline ::google::internal::federated::plan::SumOptions* OutputMetric::unsafe_arena_release_sum() {
  // @@protoc_insertion_point(field_unsafe_arena_release:google.internal.federated.plan.OutputMetric.sum)
  if (_internal_has_sum()) {
    clear_has_value_source();
    ::google::internal::federated::plan::SumOptions* temp = _impl_.value_source_.sum_;
    _impl_.value_source_.sum_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void OutputMetric::unsafe_arena_set_allocated_sum(::google::internal::federated::plan::SumOptions* sum) {
  clear_value_source();
  if (sum) {
    set_has_sum();
    _impl_.value_source_.sum_ = sum;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.OutputMetric.sum)
}
inline ::google::internal::federated::plan::SumOptions* OutputMetric::_internal_mutable_sum() {
  if (!_internal_has_sum()) {
    clear_value_source();
    set_has_sum();
    _impl_.value_source_.sum_ = CreateMaybeMessage< ::google::internal::federated::plan::SumOptions >(GetArenaForAllocation());
  }
  return _impl_.value_source_.sum_;
}
inline ::google::internal::federated::plan::SumOptions* OutputMetric::mutable_sum() {
  ::google::internal::federated::plan::SumOptions* _msg = _internal_mutable_sum();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.OutputMetric.sum)
  return _msg;
}

// .google.internal.federated.plan.AverageOptions average = 3;
inline bool OutputMetric::_internal_has_average() const {
  return value_source_case() == kAverage;
}
inline bool OutputMetric::has_average() const {
  return _internal_has_average();
}
inline void OutputMetric::set_has_average() {
  _impl_._oneof_case_[0] = kAverage;
}
inline void OutputMetric::clear_average() {
  if (_internal_has_average()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.value_source_.average_;
    }
    clear_has_value_source();
  }
}
inline ::google::internal::federated::plan::AverageOptions* OutputMetric::release_average() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.OutputMetric.average)
  if (_internal_has_average()) {
    clear_has_value_source();
    ::google::internal::federated::plan::AverageOptions* temp = _impl_.value_source_.average_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_source_.average_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::google::internal::federated::plan::AverageOptions& OutputMetric::_internal_average() const {
  return _internal_has_average()
      ? *_impl_.value_source_.average_
      : reinterpret_cast< ::google::internal::federated::plan::AverageOptions&>(::google::internal::federated::plan::_AverageOptions_default_instance_);
}
inline const ::google::internal::federated::plan::AverageOptions& OutputMetric::average() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.OutputMetric.average)
  return _internal_average();
}
inline ::google::internal::federated::plan::AverageOptions* OutputMetric::unsafe_arena_release_average() {
  // @@protoc_insertion_point(field_unsafe_arena_release:google.internal.federated.plan.OutputMetric.average)
  if (_internal_has_average()) {
    clear_has_value_source();
    ::google::internal::federated::plan::AverageOptions* temp = _impl_.value_source_.average_;
    _impl_.value_source_.average_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void OutputMetric::unsafe_arena_set_allocated_average(::google::internal::federated::plan::AverageOptions* average) {
  clear_value_source();
  if (average) {
    set_has_average();
    _impl_.value_source_.average_ = average;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.OutputMetric.average)
}
inline ::google::internal::federated::plan::AverageOptions* OutputMetric::_internal_mutable_average() {
  if (!_internal_has_average()) {
    clear_value_source();
    set_has_average();
    _impl_.value_source_.average_ = CreateMaybeMessage< ::google::internal::federated::plan::AverageOptions >(GetArenaForAllocation());
  }
  return _impl_.value_source_.average_;
}
inline ::google::internal::federated::plan::AverageOptions* OutputMetric::mutable_average() {
  ::google::internal::federated::plan::AverageOptions* _msg = _internal_mutable_average();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.OutputMetric.average)
  return _msg;
}

// .google.internal.federated.plan.NoneOptions none = 4;
inline bool OutputMetric::_internal_has_none() const {
  return value_source_case() == kNone;
}
inline bool OutputMetric::has_none() const {
  return _internal_has_none();
}
inline void OutputMetric::set_has_none() {
  _impl_._oneof_case_[0] = kNone;
}
inline void OutputMetric::clear_none() {
  if (_internal_has_none()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.value_source_.none_;
    }
    clear_has_value_source();
  }
}
inline ::google::internal::federated::plan::NoneOptions* OutputMetric::release_none() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.OutputMetric.none)
  if (_internal_has_none()) {
    clear_has_value_source();
    ::google::internal::federated::plan::NoneOptions* temp = _impl_.value_source_.none_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_source_.none_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::google::internal::federated::plan::NoneOptions& OutputMetric::_internal_none() const {
  return _internal_has_none()
      ? *_impl_.value_source_.none_
      : reinterpret_cast< ::google::internal::federated::plan::NoneOptions&>(::google::internal::federated::plan::_NoneOptions_default_instance_);
}
inline const ::google::internal::federated::plan::NoneOptions& OutputMetric::none() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.OutputMetric.none)
  return _internal_none();
}
inline ::google::internal::federated::plan::NoneOptions* OutputMetric::unsafe_arena_release_none() {
  // @@protoc_insertion_point(field_unsafe_arena_release:google.internal.federated.plan.OutputMetric.none)
  if (_internal_has_none()) {
    clear_has_value_source();
    ::google::internal::federated::plan::NoneOptions* temp = _impl_.value_source_.none_;
    _impl_.value_source_.none_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void OutputMetric::unsafe_arena_set_allocated_none(::google::internal::federated::plan::NoneOptions* none) {
  clear_value_source();
  if (none) {
    set_has_none();
    _impl_.value_source_.none_ = none;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.OutputMetric.none)
}
inline ::google::internal::federated::plan::NoneOptions* OutputMetric::_internal_mutable_none() {
  if (!_internal_has_none()) {
    clear_value_source();
    set_has_none();
    _impl_.value_source_.none_ = CreateMaybeMessage< ::google::internal::federated::plan::NoneOptions >(GetArenaForAllocation());
  }
  return _impl_.value_source_.none_;
}
inline ::google::internal::federated::plan::NoneOptions* OutputMetric::mutable_none() {
  ::google::internal::federated::plan::NoneOptions* _msg = _internal_mutable_none();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.OutputMetric.none)
  return _msg;
}

// .google.internal.federated.plan.OnlySampleOptions only_sample = 5;
inline bool OutputMetric::_internal_has_only_sample() const {
  return value_source_case() == kOnlySample;
}
inline bool OutputMetric::has_only_sample() const {
  return _internal_has_only_sample();
}
inline void OutputMetric::set_has_only_sample() {
  _impl_._oneof_case_[0] = kOnlySample;
}
inline void OutputMetric::clear_only_sample() {
  if (_internal_has_only_sample()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.value_source_.only_sample_;
    }
    clear_has_value_source();
  }
}
inline ::google::internal::federated::plan::OnlySampleOptions* OutputMetric::release_only_sample() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.OutputMetric.only_sample)
  if (_internal_has_only_sample()) {
    clear_has_value_source();
    ::google::internal::federated::plan::OnlySampleOptions* temp = _impl_.value_source_.only_sample_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.value_source_.only_sample_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::google::internal::federated::plan::OnlySampleOptions& OutputMetric::_internal_only_sample() const {
  return _internal_has_only_sample()
      ? *_impl_.value_source_.only_sample_
      : reinterpret_cast< ::google::internal::federated::plan::OnlySampleOptions&>(::google::internal::federated::plan::_OnlySampleOptions_default_instance_);
}
inline const ::google::internal::federated::plan::OnlySampleOptions& OutputMetric::only_sample() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.OutputMetric.only_sample)
  return _internal_only_sample();
}
inline ::google::internal::federated::plan::OnlySampleOptions* OutputMetric::unsafe_arena_release_only_sample() {
  // @@protoc_insertion_point(field_unsafe_arena_release:google.internal.federated.plan.OutputMetric.only_sample)
  if (_internal_has_only_sample()) {
    clear_has_value_source();
    ::google::internal::federated::plan::OnlySampleOptions* temp = _impl_.value_source_.only_sample_;
    _impl_.value_source_.only_sample_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void OutputMetric::unsafe_arena_set_allocated_only_sample(::google::internal::federated::plan::OnlySampleOptions* only_sample) {
  clear_value_source();
  if (only_sample) {
    set_has_only_sample();
    _impl_.value_source_.only_sample_ = only_sample;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.OutputMetric.only_sample)
}
inline ::google::internal::federated::plan::OnlySampleOptions* OutputMetric::_internal_mutable_only_sample() {
  if (!_internal_has_only_sample()) {
    clear_value_source();
    set_has_only_sample();
    _impl_.value_source_.only_sample_ = CreateMaybeMessage< ::google::internal::federated::plan::OnlySampleOptions >(GetArenaForAllocation());
  }
  return _impl_.value_source_.only_sample_;
}
inline ::google::internal::federated::plan::OnlySampleOptions* OutputMetric::mutable_only_sample() {
  ::google::internal::federated::plan::OnlySampleOptions* _msg = _internal_mutable_only_sample();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.OutputMetric.only_sample)
  return _msg;
}

// bool auto_plot = 6 [deprecated = true];
inline bool OutputMetric::_internal_has_auto_plot() const {
  return visualization_info_case() == kAutoPlot;
}
inline bool OutputMetric::has_auto_plot() const {
  return _internal_has_auto_plot();
}
inline void OutputMetric::set_has_auto_plot() {
  _impl_._oneof_case_[1] = kAutoPlot;
}
inline void OutputMetric::clear_auto_plot() {
  if (_internal_has_auto_plot()) {
    _impl_.visualization_info_.auto_plot_ = false;
    clear_has_visualization_info();
  }
}
inline bool OutputMetric::_internal_auto_plot() const {
  if (_internal_has_auto_plot()) {
    return _impl_.visualization_info_.auto_plot_;
  }
  return false;
}
inline void OutputMetric::_internal_set_auto_plot(bool value) {
  if (!_internal_has_auto_plot()) {
    clear_visualization_info();
    set_has_auto_plot();
  }
  _impl_.visualization_info_.auto_plot_ = value;
}
inline bool OutputMetric::auto_plot() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.OutputMetric.auto_plot)
  return _internal_auto_plot();
}
inline void OutputMetric::set_auto_plot(bool value) {
  _internal_set_auto_plot(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.OutputMetric.auto_plot)
}

// .google.internal.federated.plan.VisualizationSpec plot_spec = 7;
inline bool OutputMetric::_internal_has_plot_spec() const {
  return visualization_info_case() == kPlotSpec;
}
inline bool OutputMetric::has_plot_spec() const {
  return _internal_has_plot_spec();
}
inline void OutputMetric::set_has_plot_spec() {
  _impl_._oneof_case_[1] = kPlotSpec;
}
inline void OutputMetric::clear_plot_spec() {
  if (_internal_has_plot_spec()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.visualization_info_.plot_spec_;
    }
    clear_has_visualization_info();
  }
}
inline ::google::internal::federated::plan::VisualizationSpec* OutputMetric::release_plot_spec() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.OutputMetric.plot_spec)
  if (_internal_has_plot_spec()) {
    clear_has_visualization_info();
    ::google::internal::federated::plan::VisualizationSpec* temp = _impl_.visualization_info_.plot_spec_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.visualization_info_.plot_spec_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::google::internal::federated::plan::VisualizationSpec& OutputMetric::_internal_plot_spec() const {
  return _internal_has_plot_spec()
      ? *_impl_.visualization_info_.plot_spec_
      : reinterpret_cast< ::google::internal::federated::plan::VisualizationSpec&>(::google::internal::federated::plan::_VisualizationSpec_default_instance_);
}
inline const ::google::internal::federated::plan::VisualizationSpec& OutputMetric::plot_spec() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.OutputMetric.plot_spec)
  return _internal_plot_spec();
}
inline ::google::internal::federated::plan::VisualizationSpec* OutputMetric::unsafe_arena_release_plot_spec() {
  // @@protoc_insertion_point(field_unsafe_arena_release:google.internal.federated.plan.OutputMetric.plot_spec)
  if (_internal_has_plot_spec()) {
    clear_has_visualization_info();
    ::google::internal::federated::plan::VisualizationSpec* temp = _impl_.visualization_info_.plot_spec_;
    _impl_.visualization_info_.plot_spec_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void OutputMetric::unsafe_arena_set_allocated_plot_spec(::google::internal::federated::plan::VisualizationSpec* plot_spec) {
  clear_visualization_info();
  if (plot_spec) {
    set_has_plot_spec();
    _impl_.visualization_info_.plot_spec_ = plot_spec;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.OutputMetric.plot_spec)
}
inline ::google::internal::federated::plan::VisualizationSpec* OutputMetric::_internal_mutable_plot_spec() {
  if (!_internal_has_plot_spec()) {
    clear_visualization_info();
    set_has_plot_spec();
    _impl_.visualization_info_.plot_spec_ = CreateMaybeMessage< ::google::internal::federated::plan::VisualizationSpec >(GetArenaForAllocation());
  }
  return _impl_.visualization_info_.plot_spec_;
}
inline ::google::internal::federated::plan::VisualizationSpec* OutputMetric::mutable_plot_spec() {
  ::google::internal::federated::plan::VisualizationSpec* _msg = _internal_mutable_plot_spec();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.OutputMetric.plot_spec)
  return _msg;
}

inline bool OutputMetric::has_value_source() const {
  return value_source_case() != VALUE_SOURCE_NOT_SET;
}
inline void OutputMetric::clear_has_value_source() {
  _impl_._oneof_case_[0] = VALUE_SOURCE_NOT_SET;
}
inline bool OutputMetric::has_visualization_info() const {
  return visualization_info_case() != VISUALIZATION_INFO_NOT_SET;
}
inline void OutputMetric::clear_has_visualization_info() {
  _impl_._oneof_case_[1] = VISUALIZATION_INFO_NOT_SET;
}
inline OutputMetric::ValueSourceCase OutputMetric::value_source_case() const {
  return OutputMetric::ValueSourceCase(_impl_._oneof_case_[0]);
}
inline OutputMetric::VisualizationInfoCase OutputMetric::visualization_info_case() const {
  return OutputMetric::VisualizationInfoCase(_impl_._oneof_case_[1]);
}
// -------------------------------------------------------------------

// VisualizationSpec

// .google.internal.federated.plan.VisualizationSpec.VisualizationType plot_type = 1;
inline void VisualizationSpec::clear_plot_type() {
  _impl_.plot_type_ = 0;
}
inline ::google::internal::federated::plan::VisualizationSpec_VisualizationType VisualizationSpec::_internal_plot_type() const {
  return static_cast< ::google::internal::federated::plan::VisualizationSpec_VisualizationType >(_impl_.plot_type_);
}
inline ::google::internal::federated::plan::VisualizationSpec_VisualizationType VisualizationSpec::plot_type() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.VisualizationSpec.plot_type)
  return _internal_plot_type();
}
inline void VisualizationSpec::_internal_set_plot_type(::google::internal::federated::plan::VisualizationSpec_VisualizationType value) {

  _impl_.plot_type_ = value;
}
inline void VisualizationSpec::set_plot_type(::google::internal::federated::plan::VisualizationSpec_VisualizationType value) {
  _internal_set_plot_type(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.VisualizationSpec.plot_type)
}

// string x_axis = 2;
inline void VisualizationSpec::clear_x_axis() {
  _impl_.x_axis_.ClearToEmpty();
}
inline const std::string& VisualizationSpec::x_axis() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.VisualizationSpec.x_axis)
  return _internal_x_axis();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void VisualizationSpec::set_x_axis(ArgT0&& arg0, ArgT... args) {

 _impl_.x_axis_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.VisualizationSpec.x_axis)
}
inline std::string* VisualizationSpec::mutable_x_axis() {
  std::string* _s = _internal_mutable_x_axis();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.VisualizationSpec.x_axis)
  return _s;
}
inline const std::string& VisualizationSpec::_internal_x_axis() const {
  return _impl_.x_axis_.Get();
}
inline void VisualizationSpec::_internal_set_x_axis(const std::string& value) {

  _impl_.x_axis_.Set(value, GetArenaForAllocation());
}
inline std::string* VisualizationSpec::_internal_mutable_x_axis() {

  return _impl_.x_axis_.Mutable(GetArenaForAllocation());
}
inline std::string* VisualizationSpec::release_x_axis() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.VisualizationSpec.x_axis)
  return _impl_.x_axis_.Release();
}
inline void VisualizationSpec::set_allocated_x_axis(std::string* x_axis) {
  _impl_.x_axis_.SetAllocated(x_axis, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.x_axis_.IsDefault()) {
    _impl_.x_axis_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.VisualizationSpec.x_axis)
}

// bool plot_on_population_dashboard = 3;
inline void VisualizationSpec::clear_plot_on_population_dashboard() {
  _impl_.plot_on_population_dashboard_ = false;
}
inline bool VisualizationSpec::_internal_plot_on_population_dashboard() const {
  return _impl_.plot_on_population_dashboard_;
}
inline bool VisualizationSpec::plot_on_population_dashboard() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.VisualizationSpec.plot_on_population_dashboard)
  return _internal_plot_on_population_dashboard();
}
inline void VisualizationSpec::_internal_set_plot_on_population_dashboard(bool value) {

  _impl_.plot_on_population_dashboard_ = value;
}
inline void VisualizationSpec::set_plot_on_population_dashboard(bool value) {
  _internal_set_plot_on_population_dashboard(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.VisualizationSpec.plot_on_population_dashboard)
}

// -------------------------------------------------------------------

// SumOptions

// string stat_name = 1;
inline void SumOptions::clear_stat_name() {
  _impl_.stat_name_.ClearToEmpty();
}
inline const std::string& SumOptions::stat_name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.SumOptions.stat_name)
  return _internal_stat_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SumOptions::set_stat_name(ArgT0&& arg0, ArgT... args) {

 _impl_.stat_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.SumOptions.stat_name)
}
inline std::string* SumOptions::mutable_stat_name() {
  std::string* _s = _internal_mutable_stat_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.SumOptions.stat_name)
  return _s;
}
inline const std::string& SumOptions::_internal_stat_name() const {
  return _impl_.stat_name_.Get();
}
inline void SumOptions::_internal_set_stat_name(const std::string& value) {

  _impl_.stat_name_.Set(value, GetArenaForAllocation());
}
inline std::string* SumOptions::_internal_mutable_stat_name() {

  return _impl_.stat_name_.Mutable(GetArenaForAllocation());
}
inline std::string* SumOptions::release_stat_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.SumOptions.stat_name)
  return _impl_.stat_name_.Release();
}
inline void SumOptions::set_allocated_stat_name(std::string* stat_name) {
  _impl_.stat_name_.SetAllocated(stat_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.stat_name_.IsDefault()) {
    _impl_.stat_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.SumOptions.stat_name)
}

// bool include_cumulative_sum = 2;
inline void SumOptions::clear_include_cumulative_sum() {
  _impl_.include_cumulative_sum_ = false;
}
inline bool SumOptions::_internal_include_cumulative_sum() const {
  return _impl_.include_cumulative_sum_;
}
inline bool SumOptions::include_cumulative_sum() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.SumOptions.include_cumulative_sum)
  return _internal_include_cumulative_sum();
}
inline void SumOptions::_internal_set_include_cumulative_sum(bool value) {

  _impl_.include_cumulative_sum_ = value;
}
inline void SumOptions::set_include_cumulative_sum(bool value) {
  _internal_set_include_cumulative_sum(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.SumOptions.include_cumulative_sum)
}

// bool include_client_samples = 3;
inline void SumOptions::clear_include_client_samples() {
  _impl_.include_client_samples_ = false;
}
inline bool SumOptions::_internal_include_client_samples() const {
  return _impl_.include_client_samples_;
}
inline bool SumOptions::include_client_samples() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.SumOptions.include_client_samples)
  return _internal_include_client_samples();
}
inline void SumOptions::_internal_set_include_client_samples(bool value) {

  _impl_.include_client_samples_ = value;
}
inline void SumOptions::set_include_client_samples(bool value) {
  _internal_set_include_client_samples(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.SumOptions.include_client_samples)
}

// -------------------------------------------------------------------

// AverageOptions

// string numerator_stat_name = 1;
inline void AverageOptions::clear_numerator_stat_name() {
  _impl_.numerator_stat_name_.ClearToEmpty();
}
inline const std::string& AverageOptions::numerator_stat_name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.AverageOptions.numerator_stat_name)
  return _internal_numerator_stat_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AverageOptions::set_numerator_stat_name(ArgT0&& arg0, ArgT... args) {

 _impl_.numerator_stat_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.AverageOptions.numerator_stat_name)
}
inline std::string* AverageOptions::mutable_numerator_stat_name() {
  std::string* _s = _internal_mutable_numerator_stat_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.AverageOptions.numerator_stat_name)
  return _s;
}
inline const std::string& AverageOptions::_internal_numerator_stat_name() const {
  return _impl_.numerator_stat_name_.Get();
}
inline void AverageOptions::_internal_set_numerator_stat_name(const std::string& value) {

  _impl_.numerator_stat_name_.Set(value, GetArenaForAllocation());
}
inline std::string* AverageOptions::_internal_mutable_numerator_stat_name() {

  return _impl_.numerator_stat_name_.Mutable(GetArenaForAllocation());
}
inline std::string* AverageOptions::release_numerator_stat_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.AverageOptions.numerator_stat_name)
  return _impl_.numerator_stat_name_.Release();
}
inline void AverageOptions::set_allocated_numerator_stat_name(std::string* numerator_stat_name) {
  _impl_.numerator_stat_name_.SetAllocated(numerator_stat_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.numerator_stat_name_.IsDefault()) {
    _impl_.numerator_stat_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.AverageOptions.numerator_stat_name)
}

// string denominator_stat_name = 2;
inline void AverageOptions::clear_denominator_stat_name() {
  _impl_.denominator_stat_name_.ClearToEmpty();
}
inline const std::string& AverageOptions::denominator_stat_name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.AverageOptions.denominator_stat_name)
  return _internal_denominator_stat_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AverageOptions::set_denominator_stat_name(ArgT0&& arg0, ArgT... args) {

 _impl_.denominator_stat_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.AverageOptions.denominator_stat_name)
}
inline std::string* AverageOptions::mutable_denominator_stat_name() {
  std::string* _s = _internal_mutable_denominator_stat_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.AverageOptions.denominator_stat_name)
  return _s;
}
inline const std::string& AverageOptions::_internal_denominator_stat_name() const {
  return _impl_.denominator_stat_name_.Get();
}
inline void AverageOptions::_internal_set_denominator_stat_name(const std::string& value) {

  _impl_.denominator_stat_name_.Set(value, GetArenaForAllocation());
}
inline std::string* AverageOptions::_internal_mutable_denominator_stat_name() {

  return _impl_.denominator_stat_name_.Mutable(GetArenaForAllocation());
}
inline std::string* AverageOptions::release_denominator_stat_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.AverageOptions.denominator_stat_name)
  return _impl_.denominator_stat_name_.Release();
}
inline void AverageOptions::set_allocated_denominator_stat_name(std::string* denominator_stat_name) {
  _impl_.denominator_stat_name_.SetAllocated(denominator_stat_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.denominator_stat_name_.IsDefault()) {
    _impl_.denominator_stat_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.AverageOptions.denominator_stat_name)
}

// string average_stat_name = 3;
inline void AverageOptions::clear_average_stat_name() {
  _impl_.average_stat_name_.ClearToEmpty();
}
inline const std::string& AverageOptions::average_stat_name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.AverageOptions.average_stat_name)
  return _internal_average_stat_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AverageOptions::set_average_stat_name(ArgT0&& arg0, ArgT... args) {

 _impl_.average_stat_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.AverageOptions.average_stat_name)
}
inline std::string* AverageOptions::mutable_average_stat_name() {
  std::string* _s = _internal_mutable_average_stat_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.AverageOptions.average_stat_name)
  return _s;
}
inline const std::string& AverageOptions::_internal_average_stat_name() const {
  return _impl_.average_stat_name_.Get();
}
inline void AverageOptions::_internal_set_average_stat_name(const std::string& value) {

  _impl_.average_stat_name_.Set(value, GetArenaForAllocation());
}
inline std::string* AverageOptions::_internal_mutable_average_stat_name() {

  return _impl_.average_stat_name_.Mutable(GetArenaForAllocation());
}
inline std::string* AverageOptions::release_average_stat_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.AverageOptions.average_stat_name)
  return _impl_.average_stat_name_.Release();
}
inline void AverageOptions::set_allocated_average_stat_name(std::string* average_stat_name) {
  _impl_.average_stat_name_.SetAllocated(average_stat_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.average_stat_name_.IsDefault()) {
    _impl_.average_stat_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.AverageOptions.average_stat_name)
}

// bool include_client_samples = 4;
inline void AverageOptions::clear_include_client_samples() {
  _impl_.include_client_samples_ = false;
}
inline bool AverageOptions::_internal_include_client_samples() const {
  return _impl_.include_client_samples_;
}
inline bool AverageOptions::include_client_samples() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.AverageOptions.include_client_samples)
  return _internal_include_client_samples();
}
inline void AverageOptions::_internal_set_include_client_samples(bool value) {

  _impl_.include_client_samples_ = value;
}
inline void AverageOptions::set_include_client_samples(bool value) {
  _internal_set_include_client_samples(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.AverageOptions.include_client_samples)
}

// -------------------------------------------------------------------

// NoneOptions

// string stat_name = 1;
inline void NoneOptions::clear_stat_name() {
  _impl_.stat_name_.ClearToEmpty();
}
inline const std::string& NoneOptions::stat_name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.NoneOptions.stat_name)
  return _internal_stat_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void NoneOptions::set_stat_name(ArgT0&& arg0, ArgT... args) {

 _impl_.stat_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.NoneOptions.stat_name)
}
inline std::string* NoneOptions::mutable_stat_name() {
  std::string* _s = _internal_mutable_stat_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.NoneOptions.stat_name)
  return _s;
}
inline const std::string& NoneOptions::_internal_stat_name() const {
  return _impl_.stat_name_.Get();
}
inline void NoneOptions::_internal_set_stat_name(const std::string& value) {

  _impl_.stat_name_.Set(value, GetArenaForAllocation());
}
inline std::string* NoneOptions::_internal_mutable_stat_name() {

  return _impl_.stat_name_.Mutable(GetArenaForAllocation());
}
inline std::string* NoneOptions::release_stat_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.NoneOptions.stat_name)
  return _impl_.stat_name_.Release();
}
inline void NoneOptions::set_allocated_stat_name(std::string* stat_name) {
  _impl_.stat_name_.SetAllocated(stat_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.stat_name_.IsDefault()) {
    _impl_.stat_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.NoneOptions.stat_name)
}

// -------------------------------------------------------------------

// OnlySampleOptions

// string stat_name = 1;
inline void OnlySampleOptions::clear_stat_name() {
  _impl_.stat_name_.ClearToEmpty();
}
inline const std::string& OnlySampleOptions::stat_name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.OnlySampleOptions.stat_name)
  return _internal_stat_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void OnlySampleOptions::set_stat_name(ArgT0&& arg0, ArgT... args) {

 _impl_.stat_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.OnlySampleOptions.stat_name)
}
inline std::string* OnlySampleOptions::mutable_stat_name() {
  std::string* _s = _internal_mutable_stat_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.OnlySampleOptions.stat_name)
  return _s;
}
inline const std::string& OnlySampleOptions::_internal_stat_name() const {
  return _impl_.stat_name_.Get();
}
inline void OnlySampleOptions::_internal_set_stat_name(const std::string& value) {

  _impl_.stat_name_.Set(value, GetArenaForAllocation());
}
inline std::string* OnlySampleOptions::_internal_mutable_stat_name() {

  return _impl_.stat_name_.Mutable(GetArenaForAllocation());
}
inline std::string* OnlySampleOptions::release_stat_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.OnlySampleOptions.stat_name)
  return _impl_.stat_name_.Release();
}
inline void OnlySampleOptions::set_allocated_stat_name(std::string* stat_name) {
  _impl_.stat_name_.SetAllocated(stat_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.stat_name_.IsDefault()) {
    _impl_.stat_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.OnlySampleOptions.stat_name)
}

// -------------------------------------------------------------------

// Dataset_ClientDataset_SelectedExample

// .google.internal.federated.plan.ExampleSelector selector = 1;
inline bool Dataset_ClientDataset_SelectedExample::_internal_has_selector() const {
  return this != internal_default_instance() && _impl_.selector_ != nullptr;
}
inline bool Dataset_ClientDataset_SelectedExample::has_selector() const {
  return _internal_has_selector();
}
inline void Dataset_ClientDataset_SelectedExample::clear_selector() {
  if (GetArenaForAllocation() == nullptr && _impl_.selector_ != nullptr) {
    delete _impl_.selector_;
  }
  _impl_.selector_ = nullptr;
}
inline const ::google::internal::federated::plan::ExampleSelector& Dataset_ClientDataset_SelectedExample::_internal_selector() const {
  const ::google::internal::federated::plan::ExampleSelector* p = _impl_.selector_;
  return p != nullptr ? *p : reinterpret_cast<const ::google::internal::federated::plan::ExampleSelector&>(
      ::google::internal::federated::plan::_ExampleSelector_default_instance_);
}
inline const ::google::internal::federated::plan::ExampleSelector& Dataset_ClientDataset_SelectedExample::selector() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.Dataset.ClientDataset.SelectedExample.selector)
  return _internal_selector();
}
inline void Dataset_ClientDataset_SelectedExample::unsafe_arena_set_allocated_selector(
    ::google::internal::federated::plan::ExampleSelector* selector) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.selector_);
  }
  _impl_.selector_ = selector;
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.Dataset.ClientDataset.SelectedExample.selector)
}
inline ::google::internal::federated::plan::ExampleSelector* Dataset_ClientDataset_SelectedExample::release_selector() {

  ::google::internal::federated::plan::ExampleSelector* temp = _impl_.selector_;
  _impl_.selector_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::google::internal::federated::plan::ExampleSelector* Dataset_ClientDataset_SelectedExample::unsafe_arena_release_selector() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.Dataset.ClientDataset.SelectedExample.selector)

  ::google::internal::federated::plan::ExampleSelector* temp = _impl_.selector_;
  _impl_.selector_ = nullptr;
  return temp;
}
inline ::google::internal::federated::plan::ExampleSelector* Dataset_ClientDataset_SelectedExample::_internal_mutable_selector() {

  if (_impl_.selector_ == nullptr) {
    auto* p = CreateMaybeMessage<::google::internal::federated::plan::ExampleSelector>(GetArenaForAllocation());
    _impl_.selector_ = p;
  }
  return _impl_.selector_;
}
inline ::google::internal::federated::plan::ExampleSelector* Dataset_ClientDataset_SelectedExample::mutable_selector() {
  ::google::internal::federated::plan::ExampleSelector* _msg = _internal_mutable_selector();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.Dataset.ClientDataset.SelectedExample.selector)
  return _msg;
}
inline void Dataset_ClientDataset_SelectedExample::set_allocated_selector(::google::internal::federated::plan::ExampleSelector* selector) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.selector_;
  }
  if (selector) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(selector);
    if (message_arena != submessage_arena) {
      selector = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, selector, submessage_arena);
    }

  } else {

  }
  _impl_.selector_ = selector;
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.Dataset.ClientDataset.SelectedExample.selector)
}

// repeated bytes example = 2;
inline int Dataset_ClientDataset_SelectedExample::_internal_example_size() const {
  return _impl_.example_.size();
}
inline int Dataset_ClientDataset_SelectedExample::example_size() const {
  return _internal_example_size();
}
inline void Dataset_ClientDataset_SelectedExample::clear_example() {
  _impl_.example_.Clear();
}
inline std::string* Dataset_ClientDataset_SelectedExample::add_example() {
  std::string* _s = _internal_add_example();
  // @@protoc_insertion_point(field_add_mutable:google.internal.federated.plan.Dataset.ClientDataset.SelectedExample.example)
  return _s;
}
inline const std::string& Dataset_ClientDataset_SelectedExample::_internal_example(int index) const {
  return _impl_.example_.Get(index);
}
inline const std::string& Dataset_ClientDataset_SelectedExample::example(int index) const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.Dataset.ClientDataset.SelectedExample.example)
  return _internal_example(index);
}
inline std::string* Dataset_ClientDataset_SelectedExample::mutable_example(int index) {
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.Dataset.ClientDataset.SelectedExample.example)
  return _impl_.example_.Mutable(index);
}
inline void Dataset_ClientDataset_SelectedExample::set_example(int index, const std::string& value) {
  _impl_.example_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.Dataset.ClientDataset.SelectedExample.example)
}
inline void Dataset_ClientDataset_SelectedExample::set_example(int index, std::string&& value) {
  _impl_.example_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.Dataset.ClientDataset.SelectedExample.example)
}
inline void Dataset_ClientDataset_SelectedExample::set_example(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.example_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:google.internal.federated.plan.Dataset.ClientDataset.SelectedExample.example)
}
inline void Dataset_ClientDataset_SelectedExample::set_example(int index, const void* value, size_t size) {
  _impl_.example_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:google.internal.federated.plan.Dataset.ClientDataset.SelectedExample.example)
}
inline std::string* Dataset_ClientDataset_SelectedExample::_internal_add_example() {
  return _impl_.example_.Add();
}
inline void Dataset_ClientDataset_SelectedExample::add_example(const std::string& value) {
  _impl_.example_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:google.internal.federated.plan.Dataset.ClientDataset.SelectedExample.example)
}
inline void Dataset_ClientDataset_SelectedExample::add_example(std::string&& value) {
  _impl_.example_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:google.internal.federated.plan.Dataset.ClientDataset.SelectedExample.example)
}
inline void Dataset_ClientDataset_SelectedExample::add_example(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.example_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:google.internal.federated.plan.Dataset.ClientDataset.SelectedExample.example)
}
inline void Dataset_ClientDataset_SelectedExample::add_example(const void* value, size_t size) {
  _impl_.example_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:google.internal.federated.plan.Dataset.ClientDataset.SelectedExample.example)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Dataset_ClientDataset_SelectedExample::example() const {
  // @@protoc_insertion_point(field_list:google.internal.federated.plan.Dataset.ClientDataset.SelectedExample.example)
  return _impl_.example_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Dataset_ClientDataset_SelectedExample::mutable_example() {
  // @@protoc_insertion_point(field_mutable_list:google.internal.federated.plan.Dataset.ClientDataset.SelectedExample.example)
  return &_impl_.example_;
}

// -------------------------------------------------------------------

// Dataset_ClientDataset

// string client_id = 1;
inline void Dataset_ClientDataset::clear_client_id() {
  _impl_.client_id_.ClearToEmpty();
}
inline const std::string& Dataset_ClientDataset::client_id() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.Dataset.ClientDataset.client_id)
  return _internal_client_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Dataset_ClientDataset::set_client_id(ArgT0&& arg0, ArgT... args) {

 _impl_.client_id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.Dataset.ClientDataset.client_id)
}
inline std::string* Dataset_ClientDataset::mutable_client_id() {
  std::string* _s = _internal_mutable_client_id();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.Dataset.ClientDataset.client_id)
  return _s;
}
inline const std::string& Dataset_ClientDataset::_internal_client_id() const {
  return _impl_.client_id_.Get();
}
inline void Dataset_ClientDataset::_internal_set_client_id(const std::string& value) {

  _impl_.client_id_.Set(value, GetArenaForAllocation());
}
inline std::string* Dataset_ClientDataset::_internal_mutable_client_id() {

  return _impl_.client_id_.Mutable(GetArenaForAllocation());
}
inline std::string* Dataset_ClientDataset::release_client_id() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.Dataset.ClientDataset.client_id)
  return _impl_.client_id_.Release();
}
inline void Dataset_ClientDataset::set_allocated_client_id(std::string* client_id) {
  _impl_.client_id_.SetAllocated(client_id, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.client_id_.IsDefault()) {
    _impl_.client_id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.Dataset.ClientDataset.client_id)
}

// repeated bytes example = 2;
inline int Dataset_ClientDataset::_internal_example_size() const {
  return _impl_.example_.size();
}
inline int Dataset_ClientDataset::example_size() const {
  return _internal_example_size();
}
inline void Dataset_ClientDataset::clear_example() {
  _impl_.example_.Clear();
}
inline std::string* Dataset_ClientDataset::add_example() {
  std::string* _s = _internal_add_example();
  // @@protoc_insertion_point(field_add_mutable:google.internal.federated.plan.Dataset.ClientDataset.example)
  return _s;
}
inline const std::string& Dataset_ClientDataset::_internal_example(int index) const {
  return _impl_.example_.Get(index);
}
inline const std::string& Dataset_ClientDataset::example(int index) const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.Dataset.ClientDataset.example)
  return _internal_example(index);
}
inline std::string* Dataset_ClientDataset::mutable_example(int index) {
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.Dataset.ClientDataset.example)
  return _impl_.example_.Mutable(index);
}
inline void Dataset_ClientDataset::set_example(int index, const std::string& value) {
  _impl_.example_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.Dataset.ClientDataset.example)
}
inline void Dataset_ClientDataset::set_example(int index, std::string&& value) {
  _impl_.example_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.Dataset.ClientDataset.example)
}
inline void Dataset_ClientDataset::set_example(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.example_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:google.internal.federated.plan.Dataset.ClientDataset.example)
}
inline void Dataset_ClientDataset::set_example(int index, const void* value, size_t size) {
  _impl_.example_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:google.internal.federated.plan.Dataset.ClientDataset.example)
}
inline std::string* Dataset_ClientDataset::_internal_add_example() {
  return _impl_.example_.Add();
}
inline void Dataset_ClientDataset::add_example(const std::string& value) {
  _impl_.example_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:google.internal.federated.plan.Dataset.ClientDataset.example)
}
inline void Dataset_ClientDataset::add_example(std::string&& value) {
  _impl_.example_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:google.internal.federated.plan.Dataset.ClientDataset.example)
}
inline void Dataset_ClientDataset::add_example(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.example_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:google.internal.federated.plan.Dataset.ClientDataset.example)
}
inline void Dataset_ClientDataset::add_example(const void* value, size_t size) {
  _impl_.example_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:google.internal.federated.plan.Dataset.ClientDataset.example)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Dataset_ClientDataset::example() const {
  // @@protoc_insertion_point(field_list:google.internal.federated.plan.Dataset.ClientDataset.example)
  return _impl_.example_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Dataset_ClientDataset::mutable_example() {
  // @@protoc_insertion_point(field_mutable_list:google.internal.federated.plan.Dataset.ClientDataset.example)
  return &_impl_.example_;
}

// repeated .google.internal.federated.plan.Dataset.ClientDataset.SelectedExample selected_example = 3;
inline int Dataset_ClientDataset::_internal_selected_example_size() const {
  return _impl_.selected_example_.size();
}
inline int Dataset_ClientDataset::selected_example_size() const {
  return _internal_selected_example_size();
}
inline void Dataset_ClientDataset::clear_selected_example() {
  _impl_.selected_example_.Clear();
}
inline ::google::internal::federated::plan::Dataset_ClientDataset_SelectedExample* Dataset_ClientDataset::mutable_selected_example(int index) {
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.Dataset.ClientDataset.selected_example)
  return _impl_.selected_example_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::Dataset_ClientDataset_SelectedExample >*
Dataset_ClientDataset::mutable_selected_example() {
  // @@protoc_insertion_point(field_mutable_list:google.internal.federated.plan.Dataset.ClientDataset.selected_example)
  return &_impl_.selected_example_;
}
inline const ::google::internal::federated::plan::Dataset_ClientDataset_SelectedExample& Dataset_ClientDataset::_internal_selected_example(int index) const {
  return _impl_.selected_example_.Get(index);
}
inline const ::google::internal::federated::plan::Dataset_ClientDataset_SelectedExample& Dataset_ClientDataset::selected_example(int index) const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.Dataset.ClientDataset.selected_example)
  return _internal_selected_example(index);
}
inline ::google::internal::federated::plan::Dataset_ClientDataset_SelectedExample* Dataset_ClientDataset::_internal_add_selected_example() {
  return _impl_.selected_example_.Add();
}
inline ::google::internal::federated::plan::Dataset_ClientDataset_SelectedExample* Dataset_ClientDataset::add_selected_example() {
  ::google::internal::federated::plan::Dataset_ClientDataset_SelectedExample* _add = _internal_add_selected_example();
  // @@protoc_insertion_point(field_add:google.internal.federated.plan.Dataset.ClientDataset.selected_example)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::Dataset_ClientDataset_SelectedExample >&
Dataset_ClientDataset::selected_example() const {
  // @@protoc_insertion_point(field_list:google.internal.federated.plan.Dataset.ClientDataset.selected_example)
  return _impl_.selected_example_;
}

// -------------------------------------------------------------------

// Dataset

// repeated .google.internal.federated.plan.Dataset.ClientDataset client_data = 1;
inline int Dataset::_internal_client_data_size() const {
  return _impl_.client_data_.size();
}
inline int Dataset::client_data_size() const {
  return _internal_client_data_size();
}
inline void Dataset::clear_client_data() {
  _impl_.client_data_.Clear();
}
inline ::google::internal::federated::plan::Dataset_ClientDataset* Dataset::mutable_client_data(int index) {
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.Dataset.client_data)
  return _impl_.client_data_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::Dataset_ClientDataset >*
Dataset::mutable_client_data() {
  // @@protoc_insertion_point(field_mutable_list:google.internal.federated.plan.Dataset.client_data)
  return &_impl_.client_data_;
}
inline const ::google::internal::federated::plan::Dataset_ClientDataset& Dataset::_internal_client_data(int index) const {
  return _impl_.client_data_.Get(index);
}
inline const ::google::internal::federated::plan::Dataset_ClientDataset& Dataset::client_data(int index) const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.Dataset.client_data)
  return _internal_client_data(index);
}
inline ::google::internal::federated::plan::Dataset_ClientDataset* Dataset::_internal_add_client_data() {
  return _impl_.client_data_.Add();
}
inline ::google::internal::federated::plan::Dataset_ClientDataset* Dataset::add_client_data() {
  ::google::internal::federated::plan::Dataset_ClientDataset* _add = _internal_add_client_data();
  // @@protoc_insertion_point(field_add:google.internal.federated.plan.Dataset.client_data)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::Dataset_ClientDataset >&
Dataset::client_data() const {
  // @@protoc_insertion_point(field_list:google.internal.federated.plan.Dataset.client_data)
  return _impl_.client_data_;
}

// -------------------------------------------------------------------

// MetricTestPredicates_Interval

// double lower_bound = 1;
inline void MetricTestPredicates_Interval::clear_lower_bound() {
  _impl_.lower_bound_ = 0;
}
inline double MetricTestPredicates_Interval::_internal_lower_bound() const {
  return _impl_.lower_bound_;
}
inline double MetricTestPredicates_Interval::lower_bound() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.MetricTestPredicates.Interval.lower_bound)
  return _internal_lower_bound();
}
inline void MetricTestPredicates_Interval::_internal_set_lower_bound(double value) {

  _impl_.lower_bound_ = value;
}
inline void MetricTestPredicates_Interval::set_lower_bound(double value) {
  _internal_set_lower_bound(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.MetricTestPredicates.Interval.lower_bound)
}

// double upper_bound = 2;
inline void MetricTestPredicates_Interval::clear_upper_bound() {
  _impl_.upper_bound_ = 0;
}
inline double MetricTestPredicates_Interval::_internal_upper_bound() const {
  return _impl_.upper_bound_;
}
inline double MetricTestPredicates_Interval::upper_bound() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.MetricTestPredicates.Interval.upper_bound)
  return _internal_upper_bound();
}
inline void MetricTestPredicates_Interval::_internal_set_upper_bound(double value) {

  _impl_.upper_bound_ = value;
}
inline void MetricTestPredicates_Interval::set_upper_bound(double value) {
  _internal_set_upper_bound(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.MetricTestPredicates.Interval.upper_bound)
}

// -------------------------------------------------------------------

// MetricTestPredicates_RealIfNonzeroWeight

// string weight_name = 1;
inline void MetricTestPredicates_RealIfNonzeroWeight::clear_weight_name() {
  _impl_.weight_name_.ClearToEmpty();
}
inline const std::string& MetricTestPredicates_RealIfNonzeroWeight::weight_name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.MetricTestPredicates.RealIfNonzeroWeight.weight_name)
  return _internal_weight_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MetricTestPredicates_RealIfNonzeroWeight::set_weight_name(ArgT0&& arg0, ArgT... args) {

 _impl_.weight_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.MetricTestPredicates.RealIfNonzeroWeight.weight_name)
}
inline std::string* MetricTestPredicates_RealIfNonzeroWeight::mutable_weight_name() {
  std::string* _s = _internal_mutable_weight_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.MetricTestPredicates.RealIfNonzeroWeight.weight_name)
  return _s;
}
inline const std::string& MetricTestPredicates_RealIfNonzeroWeight::_internal_weight_name() const {
  return _impl_.weight_name_.Get();
}
inline void MetricTestPredicates_RealIfNonzeroWeight::_internal_set_weight_name(const std::string& value) {

  _impl_.weight_name_.Set(value, GetArenaForAllocation());
}
inline std::string* MetricTestPredicates_RealIfNonzeroWeight::_internal_mutable_weight_name() {

  return _impl_.weight_name_.Mutable(GetArenaForAllocation());
}
inline std::string* MetricTestPredicates_RealIfNonzeroWeight::release_weight_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.MetricTestPredicates.RealIfNonzeroWeight.weight_name)
  return _impl_.weight_name_.Release();
}
inline void MetricTestPredicates_RealIfNonzeroWeight::set_allocated_weight_name(std::string* weight_name) {
  _impl_.weight_name_.SetAllocated(weight_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.weight_name_.IsDefault()) {
    _impl_.weight_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.MetricTestPredicates.RealIfNonzeroWeight.weight_name)
}

// -------------------------------------------------------------------

// MetricTestPredicates_MetricCriterion

// string name = 1;
inline void MetricTestPredicates_MetricCriterion::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& MetricTestPredicates_MetricCriterion::name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.MetricTestPredicates.MetricCriterion.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MetricTestPredicates_MetricCriterion::set_name(ArgT0&& arg0, ArgT... args) {

 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.MetricTestPredicates.MetricCriterion.name)
}
inline std::string* MetricTestPredicates_MetricCriterion::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.MetricTestPredicates.MetricCriterion.name)
  return _s;
}
inline const std::string& MetricTestPredicates_MetricCriterion::_internal_name() const {
  return _impl_.name_.Get();
}
inline void MetricTestPredicates_MetricCriterion::_internal_set_name(const std::string& value) {

  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* MetricTestPredicates_MetricCriterion::_internal_mutable_name() {

  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* MetricTestPredicates_MetricCriterion::release_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.MetricTestPredicates.MetricCriterion.name)
  return _impl_.name_.Release();
}
inline void MetricTestPredicates_MetricCriterion::set_allocated_name(std::string* name) {
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.MetricTestPredicates.MetricCriterion.name)
}

// int32 training_round_index = 2;
inline void MetricTestPredicates_MetricCriterion::clear_training_round_index() {
  _impl_.training_round_index_ = 0;
}
inline ::int32_t MetricTestPredicates_MetricCriterion::_internal_training_round_index() const {
  return _impl_.training_round_index_;
}
inline ::int32_t MetricTestPredicates_MetricCriterion::training_round_index() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.MetricTestPredicates.MetricCriterion.training_round_index)
  return _internal_training_round_index();
}
inline void MetricTestPredicates_MetricCriterion::_internal_set_training_round_index(::int32_t value) {

  _impl_.training_round_index_ = value;
}
inline void MetricTestPredicates_MetricCriterion::set_training_round_index(::int32_t value) {
  _internal_set_training_round_index(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.MetricTestPredicates.MetricCriterion.training_round_index)
}

// float lt = 3;
inline bool MetricTestPredicates_MetricCriterion::_internal_has_lt() const {
  return Criterion_case() == kLt;
}
inline bool MetricTestPredicates_MetricCriterion::has_lt() const {
  return _internal_has_lt();
}
inline void MetricTestPredicates_MetricCriterion::set_has_lt() {
  _impl_._oneof_case_[0] = kLt;
}
inline void MetricTestPredicates_MetricCriterion::clear_lt() {
  if (_internal_has_lt()) {
    _impl_.Criterion_.lt_ = 0;
    clear_has_Criterion();
  }
}
inline float MetricTestPredicates_MetricCriterion::_internal_lt() const {
  if (_internal_has_lt()) {
    return _impl_.Criterion_.lt_;
  }
  return 0;
}
inline void MetricTestPredicates_MetricCriterion::_internal_set_lt(float value) {
  if (!_internal_has_lt()) {
    clear_Criterion();
    set_has_lt();
  }
  _impl_.Criterion_.lt_ = value;
}
inline float MetricTestPredicates_MetricCriterion::lt() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.MetricTestPredicates.MetricCriterion.lt)
  return _internal_lt();
}
inline void MetricTestPredicates_MetricCriterion::set_lt(float value) {
  _internal_set_lt(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.MetricTestPredicates.MetricCriterion.lt)
}

// float gt = 4;
inline bool MetricTestPredicates_MetricCriterion::_internal_has_gt() const {
  return Criterion_case() == kGt;
}
inline bool MetricTestPredicates_MetricCriterion::has_gt() const {
  return _internal_has_gt();
}
inline void MetricTestPredicates_MetricCriterion::set_has_gt() {
  _impl_._oneof_case_[0] = kGt;
}
inline void MetricTestPredicates_MetricCriterion::clear_gt() {
  if (_internal_has_gt()) {
    _impl_.Criterion_.gt_ = 0;
    clear_has_Criterion();
  }
}
inline float MetricTestPredicates_MetricCriterion::_internal_gt() const {
  if (_internal_has_gt()) {
    return _impl_.Criterion_.gt_;
  }
  return 0;
}
inline void MetricTestPredicates_MetricCriterion::_internal_set_gt(float value) {
  if (!_internal_has_gt()) {
    clear_Criterion();
    set_has_gt();
  }
  _impl_.Criterion_.gt_ = value;
}
inline float MetricTestPredicates_MetricCriterion::gt() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.MetricTestPredicates.MetricCriterion.gt)
  return _internal_gt();
}
inline void MetricTestPredicates_MetricCriterion::set_gt(float value) {
  _internal_set_gt(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.MetricTestPredicates.MetricCriterion.gt)
}

// float le = 5;
inline bool MetricTestPredicates_MetricCriterion::_internal_has_le() const {
  return Criterion_case() == kLe;
}
inline bool MetricTestPredicates_MetricCriterion::has_le() const {
  return _internal_has_le();
}
inline void MetricTestPredicates_MetricCriterion::set_has_le() {
  _impl_._oneof_case_[0] = kLe;
}
inline void MetricTestPredicates_MetricCriterion::clear_le() {
  if (_internal_has_le()) {
    _impl_.Criterion_.le_ = 0;
    clear_has_Criterion();
  }
}
inline float MetricTestPredicates_MetricCriterion::_internal_le() const {
  if (_internal_has_le()) {
    return _impl_.Criterion_.le_;
  }
  return 0;
}
inline void MetricTestPredicates_MetricCriterion::_internal_set_le(float value) {
  if (!_internal_has_le()) {
    clear_Criterion();
    set_has_le();
  }
  _impl_.Criterion_.le_ = value;
}
inline float MetricTestPredicates_MetricCriterion::le() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.MetricTestPredicates.MetricCriterion.le)
  return _internal_le();
}
inline void MetricTestPredicates_MetricCriterion::set_le(float value) {
  _internal_set_le(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.MetricTestPredicates.MetricCriterion.le)
}

// float ge = 6;
inline bool MetricTestPredicates_MetricCriterion::_internal_has_ge() const {
  return Criterion_case() == kGe;
}
inline bool MetricTestPredicates_MetricCriterion::has_ge() const {
  return _internal_has_ge();
}
inline void MetricTestPredicates_MetricCriterion::set_has_ge() {
  _impl_._oneof_case_[0] = kGe;
}
inline void MetricTestPredicates_MetricCriterion::clear_ge() {
  if (_internal_has_ge()) {
    _impl_.Criterion_.ge_ = 0;
    clear_has_Criterion();
  }
}
inline float MetricTestPredicates_MetricCriterion::_internal_ge() const {
  if (_internal_has_ge()) {
    return _impl_.Criterion_.ge_;
  }
  return 0;
}
inline void MetricTestPredicates_MetricCriterion::_internal_set_ge(float value) {
  if (!_internal_has_ge()) {
    clear_Criterion();
    set_has_ge();
  }
  _impl_.Criterion_.ge_ = value;
}
inline float MetricTestPredicates_MetricCriterion::ge() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.MetricTestPredicates.MetricCriterion.ge)
  return _internal_ge();
}
inline void MetricTestPredicates_MetricCriterion::set_ge(float value) {
  _internal_set_ge(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.MetricTestPredicates.MetricCriterion.ge)
}

// float eq = 7;
inline bool MetricTestPredicates_MetricCriterion::_internal_has_eq() const {
  return Criterion_case() == kEq;
}
inline bool MetricTestPredicates_MetricCriterion::has_eq() const {
  return _internal_has_eq();
}
inline void MetricTestPredicates_MetricCriterion::set_has_eq() {
  _impl_._oneof_case_[0] = kEq;
}
inline void MetricTestPredicates_MetricCriterion::clear_eq() {
  if (_internal_has_eq()) {
    _impl_.Criterion_.eq_ = 0;
    clear_has_Criterion();
  }
}
inline float MetricTestPredicates_MetricCriterion::_internal_eq() const {
  if (_internal_has_eq()) {
    return _impl_.Criterion_.eq_;
  }
  return 0;
}
inline void MetricTestPredicates_MetricCriterion::_internal_set_eq(float value) {
  if (!_internal_has_eq()) {
    clear_Criterion();
    set_has_eq();
  }
  _impl_.Criterion_.eq_ = value;
}
inline float MetricTestPredicates_MetricCriterion::eq() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.MetricTestPredicates.MetricCriterion.eq)
  return _internal_eq();
}
inline void MetricTestPredicates_MetricCriterion::set_eq(float value) {
  _internal_set_eq(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.MetricTestPredicates.MetricCriterion.eq)
}

// .google.internal.federated.plan.MetricTestPredicates.Interval interval = 8;
inline bool MetricTestPredicates_MetricCriterion::_internal_has_interval() const {
  return Criterion_case() == kInterval;
}
inline bool MetricTestPredicates_MetricCriterion::has_interval() const {
  return _internal_has_interval();
}
inline void MetricTestPredicates_MetricCriterion::set_has_interval() {
  _impl_._oneof_case_[0] = kInterval;
}
inline void MetricTestPredicates_MetricCriterion::clear_interval() {
  if (_internal_has_interval()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.Criterion_.interval_;
    }
    clear_has_Criterion();
  }
}
inline ::google::internal::federated::plan::MetricTestPredicates_Interval* MetricTestPredicates_MetricCriterion::release_interval() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.MetricTestPredicates.MetricCriterion.interval)
  if (_internal_has_interval()) {
    clear_has_Criterion();
    ::google::internal::federated::plan::MetricTestPredicates_Interval* temp = _impl_.Criterion_.interval_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.Criterion_.interval_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::google::internal::federated::plan::MetricTestPredicates_Interval& MetricTestPredicates_MetricCriterion::_internal_interval() const {
  return _internal_has_interval()
      ? *_impl_.Criterion_.interval_
      : reinterpret_cast< ::google::internal::federated::plan::MetricTestPredicates_Interval&>(::google::internal::federated::plan::_MetricTestPredicates_Interval_default_instance_);
}
inline const ::google::internal::federated::plan::MetricTestPredicates_Interval& MetricTestPredicates_MetricCriterion::interval() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.MetricTestPredicates.MetricCriterion.interval)
  return _internal_interval();
}
inline ::google::internal::federated::plan::MetricTestPredicates_Interval* MetricTestPredicates_MetricCriterion::unsafe_arena_release_interval() {
  // @@protoc_insertion_point(field_unsafe_arena_release:google.internal.federated.plan.MetricTestPredicates.MetricCriterion.interval)
  if (_internal_has_interval()) {
    clear_has_Criterion();
    ::google::internal::federated::plan::MetricTestPredicates_Interval* temp = _impl_.Criterion_.interval_;
    _impl_.Criterion_.interval_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void MetricTestPredicates_MetricCriterion::unsafe_arena_set_allocated_interval(::google::internal::federated::plan::MetricTestPredicates_Interval* interval) {
  clear_Criterion();
  if (interval) {
    set_has_interval();
    _impl_.Criterion_.interval_ = interval;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.MetricTestPredicates.MetricCriterion.interval)
}
inline ::google::internal::federated::plan::MetricTestPredicates_Interval* MetricTestPredicates_MetricCriterion::_internal_mutable_interval() {
  if (!_internal_has_interval()) {
    clear_Criterion();
    set_has_interval();
    _impl_.Criterion_.interval_ = CreateMaybeMessage< ::google::internal::federated::plan::MetricTestPredicates_Interval >(GetArenaForAllocation());
  }
  return _impl_.Criterion_.interval_;
}
inline ::google::internal::federated::plan::MetricTestPredicates_Interval* MetricTestPredicates_MetricCriterion::mutable_interval() {
  ::google::internal::federated::plan::MetricTestPredicates_Interval* _msg = _internal_mutable_interval();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.MetricTestPredicates.MetricCriterion.interval)
  return _msg;
}

// bool real = 9;
inline bool MetricTestPredicates_MetricCriterion::_internal_has_real() const {
  return Criterion_case() == kReal;
}
inline bool MetricTestPredicates_MetricCriterion::has_real() const {
  return _internal_has_real();
}
inline void MetricTestPredicates_MetricCriterion::set_has_real() {
  _impl_._oneof_case_[0] = kReal;
}
inline void MetricTestPredicates_MetricCriterion::clear_real() {
  if (_internal_has_real()) {
    _impl_.Criterion_.real_ = false;
    clear_has_Criterion();
  }
}
inline bool MetricTestPredicates_MetricCriterion::_internal_real() const {
  if (_internal_has_real()) {
    return _impl_.Criterion_.real_;
  }
  return false;
}
inline void MetricTestPredicates_MetricCriterion::_internal_set_real(bool value) {
  if (!_internal_has_real()) {
    clear_Criterion();
    set_has_real();
  }
  _impl_.Criterion_.real_ = value;
}
inline bool MetricTestPredicates_MetricCriterion::real() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.MetricTestPredicates.MetricCriterion.real)
  return _internal_real();
}
inline void MetricTestPredicates_MetricCriterion::set_real(bool value) {
  _internal_set_real(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.MetricTestPredicates.MetricCriterion.real)
}

// .google.internal.federated.plan.MetricTestPredicates.RealIfNonzeroWeight real_if_nonzero_weight = 10;
inline bool MetricTestPredicates_MetricCriterion::_internal_has_real_if_nonzero_weight() const {
  return Criterion_case() == kRealIfNonzeroWeight;
}
inline bool MetricTestPredicates_MetricCriterion::has_real_if_nonzero_weight() const {
  return _internal_has_real_if_nonzero_weight();
}
inline void MetricTestPredicates_MetricCriterion::set_has_real_if_nonzero_weight() {
  _impl_._oneof_case_[0] = kRealIfNonzeroWeight;
}
inline void MetricTestPredicates_MetricCriterion::clear_real_if_nonzero_weight() {
  if (_internal_has_real_if_nonzero_weight()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.Criterion_.real_if_nonzero_weight_;
    }
    clear_has_Criterion();
  }
}
inline ::google::internal::federated::plan::MetricTestPredicates_RealIfNonzeroWeight* MetricTestPredicates_MetricCriterion::release_real_if_nonzero_weight() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.MetricTestPredicates.MetricCriterion.real_if_nonzero_weight)
  if (_internal_has_real_if_nonzero_weight()) {
    clear_has_Criterion();
    ::google::internal::federated::plan::MetricTestPredicates_RealIfNonzeroWeight* temp = _impl_.Criterion_.real_if_nonzero_weight_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.Criterion_.real_if_nonzero_weight_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::google::internal::federated::plan::MetricTestPredicates_RealIfNonzeroWeight& MetricTestPredicates_MetricCriterion::_internal_real_if_nonzero_weight() const {
  return _internal_has_real_if_nonzero_weight()
      ? *_impl_.Criterion_.real_if_nonzero_weight_
      : reinterpret_cast< ::google::internal::federated::plan::MetricTestPredicates_RealIfNonzeroWeight&>(::google::internal::federated::plan::_MetricTestPredicates_RealIfNonzeroWeight_default_instance_);
}
inline const ::google::internal::federated::plan::MetricTestPredicates_RealIfNonzeroWeight& MetricTestPredicates_MetricCriterion::real_if_nonzero_weight() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.MetricTestPredicates.MetricCriterion.real_if_nonzero_weight)
  return _internal_real_if_nonzero_weight();
}
inline ::google::internal::federated::plan::MetricTestPredicates_RealIfNonzeroWeight* MetricTestPredicates_MetricCriterion::unsafe_arena_release_real_if_nonzero_weight() {
  // @@protoc_insertion_point(field_unsafe_arena_release:google.internal.federated.plan.MetricTestPredicates.MetricCriterion.real_if_nonzero_weight)
  if (_internal_has_real_if_nonzero_weight()) {
    clear_has_Criterion();
    ::google::internal::federated::plan::MetricTestPredicates_RealIfNonzeroWeight* temp = _impl_.Criterion_.real_if_nonzero_weight_;
    _impl_.Criterion_.real_if_nonzero_weight_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void MetricTestPredicates_MetricCriterion::unsafe_arena_set_allocated_real_if_nonzero_weight(::google::internal::federated::plan::MetricTestPredicates_RealIfNonzeroWeight* real_if_nonzero_weight) {
  clear_Criterion();
  if (real_if_nonzero_weight) {
    set_has_real_if_nonzero_weight();
    _impl_.Criterion_.real_if_nonzero_weight_ = real_if_nonzero_weight;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.MetricTestPredicates.MetricCriterion.real_if_nonzero_weight)
}
inline ::google::internal::federated::plan::MetricTestPredicates_RealIfNonzeroWeight* MetricTestPredicates_MetricCriterion::_internal_mutable_real_if_nonzero_weight() {
  if (!_internal_has_real_if_nonzero_weight()) {
    clear_Criterion();
    set_has_real_if_nonzero_weight();
    _impl_.Criterion_.real_if_nonzero_weight_ = CreateMaybeMessage< ::google::internal::federated::plan::MetricTestPredicates_RealIfNonzeroWeight >(GetArenaForAllocation());
  }
  return _impl_.Criterion_.real_if_nonzero_weight_;
}
inline ::google::internal::federated::plan::MetricTestPredicates_RealIfNonzeroWeight* MetricTestPredicates_MetricCriterion::mutable_real_if_nonzero_weight() {
  ::google::internal::federated::plan::MetricTestPredicates_RealIfNonzeroWeight* _msg = _internal_mutable_real_if_nonzero_weight();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.MetricTestPredicates.MetricCriterion.real_if_nonzero_weight)
  return _msg;
}

inline bool MetricTestPredicates_MetricCriterion::has_Criterion() const {
  return Criterion_case() != CRITERION_NOT_SET;
}
inline void MetricTestPredicates_MetricCriterion::clear_has_Criterion() {
  _impl_._oneof_case_[0] = CRITERION_NOT_SET;
}
inline MetricTestPredicates_MetricCriterion::CriterionCase MetricTestPredicates_MetricCriterion::Criterion_case() const {
  return MetricTestPredicates_MetricCriterion::CriterionCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// MetricTestPredicates

// repeated .google.internal.federated.plan.MetricTestPredicates.MetricCriterion metric_criterion = 1;
inline int MetricTestPredicates::_internal_metric_criterion_size() const {
  return _impl_.metric_criterion_.size();
}
inline int MetricTestPredicates::metric_criterion_size() const {
  return _internal_metric_criterion_size();
}
inline void MetricTestPredicates::clear_metric_criterion() {
  _impl_.metric_criterion_.Clear();
}
inline ::google::internal::federated::plan::MetricTestPredicates_MetricCriterion* MetricTestPredicates::mutable_metric_criterion(int index) {
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.MetricTestPredicates.metric_criterion)
  return _impl_.metric_criterion_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::MetricTestPredicates_MetricCriterion >*
MetricTestPredicates::mutable_metric_criterion() {
  // @@protoc_insertion_point(field_mutable_list:google.internal.federated.plan.MetricTestPredicates.metric_criterion)
  return &_impl_.metric_criterion_;
}
inline const ::google::internal::federated::plan::MetricTestPredicates_MetricCriterion& MetricTestPredicates::_internal_metric_criterion(int index) const {
  return _impl_.metric_criterion_.Get(index);
}
inline const ::google::internal::federated::plan::MetricTestPredicates_MetricCriterion& MetricTestPredicates::metric_criterion(int index) const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.MetricTestPredicates.metric_criterion)
  return _internal_metric_criterion(index);
}
inline ::google::internal::federated::plan::MetricTestPredicates_MetricCriterion* MetricTestPredicates::_internal_add_metric_criterion() {
  return _impl_.metric_criterion_.Add();
}
inline ::google::internal::federated::plan::MetricTestPredicates_MetricCriterion* MetricTestPredicates::add_metric_criterion() {
  ::google::internal::federated::plan::MetricTestPredicates_MetricCriterion* _add = _internal_add_metric_criterion();
  // @@protoc_insertion_point(field_add:google.internal.federated.plan.MetricTestPredicates.metric_criterion)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::MetricTestPredicates_MetricCriterion >&
MetricTestPredicates::metric_criterion() const {
  // @@protoc_insertion_point(field_list:google.internal.federated.plan.MetricTestPredicates.metric_criterion)
  return _impl_.metric_criterion_;
}

// -------------------------------------------------------------------

// ClientPhase

// string name = 2;
inline void ClientPhase::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& ClientPhase::name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ClientPhase.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClientPhase::set_name(ArgT0&& arg0, ArgT... args) {

 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.ClientPhase.name)
}
inline std::string* ClientPhase::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ClientPhase.name)
  return _s;
}
inline const std::string& ClientPhase::_internal_name() const {
  return _impl_.name_.Get();
}
inline void ClientPhase::_internal_set_name(const std::string& value) {

  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* ClientPhase::_internal_mutable_name() {

  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* ClientPhase::release_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ClientPhase.name)
  return _impl_.name_.Release();
}
inline void ClientPhase::set_allocated_name(std::string* name) {
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ClientPhase.name)
}

// int32 minimum_number_of_participants = 3;
inline void ClientPhase::clear_minimum_number_of_participants() {
  _impl_.minimum_number_of_participants_ = 0;
}
inline ::int32_t ClientPhase::_internal_minimum_number_of_participants() const {
  return _impl_.minimum_number_of_participants_;
}
inline ::int32_t ClientPhase::minimum_number_of_participants() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ClientPhase.minimum_number_of_participants)
  return _internal_minimum_number_of_participants();
}
inline void ClientPhase::_internal_set_minimum_number_of_participants(::int32_t value) {

  _impl_.minimum_number_of_participants_ = value;
}
inline void ClientPhase::set_minimum_number_of_participants(::int32_t value) {
  _internal_set_minimum_number_of_participants(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.ClientPhase.minimum_number_of_participants)
}

// .google.internal.federated.plan.TensorflowSpec tensorflow_spec = 4 [lazy = true];
inline bool ClientPhase::_internal_has_tensorflow_spec() const {
  return spec_case() == kTensorflowSpec;
}
inline bool ClientPhase::has_tensorflow_spec() const {
  return _internal_has_tensorflow_spec();
}
inline void ClientPhase::set_has_tensorflow_spec() {
  _impl_._oneof_case_[0] = kTensorflowSpec;
}
inline void ClientPhase::clear_tensorflow_spec() {
  if (_internal_has_tensorflow_spec()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.spec_.tensorflow_spec_;
    }
    clear_has_spec();
  }
}
inline ::google::internal::federated::plan::TensorflowSpec* ClientPhase::release_tensorflow_spec() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ClientPhase.tensorflow_spec)
  if (_internal_has_tensorflow_spec()) {
    clear_has_spec();
    ::google::internal::federated::plan::TensorflowSpec* temp = _impl_.spec_.tensorflow_spec_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.spec_.tensorflow_spec_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::google::internal::federated::plan::TensorflowSpec& ClientPhase::_internal_tensorflow_spec() const {
  return _internal_has_tensorflow_spec()
      ? *_impl_.spec_.tensorflow_spec_
      : reinterpret_cast< ::google::internal::federated::plan::TensorflowSpec&>(::google::internal::federated::plan::_TensorflowSpec_default_instance_);
}
inline const ::google::internal::federated::plan::TensorflowSpec& ClientPhase::tensorflow_spec() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ClientPhase.tensorflow_spec)
  return _internal_tensorflow_spec();
}
inline ::google::internal::federated::plan::TensorflowSpec* ClientPhase::unsafe_arena_release_tensorflow_spec() {
  // @@protoc_insertion_point(field_unsafe_arena_release:google.internal.federated.plan.ClientPhase.tensorflow_spec)
  if (_internal_has_tensorflow_spec()) {
    clear_has_spec();
    ::google::internal::federated::plan::TensorflowSpec* temp = _impl_.spec_.tensorflow_spec_;
    _impl_.spec_.tensorflow_spec_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ClientPhase::unsafe_arena_set_allocated_tensorflow_spec(::google::internal::federated::plan::TensorflowSpec* tensorflow_spec) {
  clear_spec();
  if (tensorflow_spec) {
    set_has_tensorflow_spec();
    _impl_.spec_.tensorflow_spec_ = tensorflow_spec;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.ClientPhase.tensorflow_spec)
}
inline ::google::internal::federated::plan::TensorflowSpec* ClientPhase::_internal_mutable_tensorflow_spec() {
  if (!_internal_has_tensorflow_spec()) {
    clear_spec();
    set_has_tensorflow_spec();
    _impl_.spec_.tensorflow_spec_ = CreateMaybeMessage< ::google::internal::federated::plan::TensorflowSpec >(GetArenaForAllocation());
  }
  return _impl_.spec_.tensorflow_spec_;
}
inline ::google::internal::federated::plan::TensorflowSpec* ClientPhase::mutable_tensorflow_spec() {
  ::google::internal::federated::plan::TensorflowSpec* _msg = _internal_mutable_tensorflow_spec();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ClientPhase.tensorflow_spec)
  return _msg;
}

// .google.internal.federated.plan.ExampleQuerySpec example_query_spec = 9 [lazy = true];
inline bool ClientPhase::_internal_has_example_query_spec() const {
  return spec_case() == kExampleQuerySpec;
}
inline bool ClientPhase::has_example_query_spec() const {
  return _internal_has_example_query_spec();
}
inline void ClientPhase::set_has_example_query_spec() {
  _impl_._oneof_case_[0] = kExampleQuerySpec;
}
inline void ClientPhase::clear_example_query_spec() {
  if (_internal_has_example_query_spec()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.spec_.example_query_spec_;
    }
    clear_has_spec();
  }
}
inline ::google::internal::federated::plan::ExampleQuerySpec* ClientPhase::release_example_query_spec() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ClientPhase.example_query_spec)
  if (_internal_has_example_query_spec()) {
    clear_has_spec();
    ::google::internal::federated::plan::ExampleQuerySpec* temp = _impl_.spec_.example_query_spec_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.spec_.example_query_spec_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::google::internal::federated::plan::ExampleQuerySpec& ClientPhase::_internal_example_query_spec() const {
  return _internal_has_example_query_spec()
      ? *_impl_.spec_.example_query_spec_
      : reinterpret_cast< ::google::internal::federated::plan::ExampleQuerySpec&>(::google::internal::federated::plan::_ExampleQuerySpec_default_instance_);
}
inline const ::google::internal::federated::plan::ExampleQuerySpec& ClientPhase::example_query_spec() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ClientPhase.example_query_spec)
  return _internal_example_query_spec();
}
inline ::google::internal::federated::plan::ExampleQuerySpec* ClientPhase::unsafe_arena_release_example_query_spec() {
  // @@protoc_insertion_point(field_unsafe_arena_release:google.internal.federated.plan.ClientPhase.example_query_spec)
  if (_internal_has_example_query_spec()) {
    clear_has_spec();
    ::google::internal::federated::plan::ExampleQuerySpec* temp = _impl_.spec_.example_query_spec_;
    _impl_.spec_.example_query_spec_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ClientPhase::unsafe_arena_set_allocated_example_query_spec(::google::internal::federated::plan::ExampleQuerySpec* example_query_spec) {
  clear_spec();
  if (example_query_spec) {
    set_has_example_query_spec();
    _impl_.spec_.example_query_spec_ = example_query_spec;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.ClientPhase.example_query_spec)
}
inline ::google::internal::federated::plan::ExampleQuerySpec* ClientPhase::_internal_mutable_example_query_spec() {
  if (!_internal_has_example_query_spec()) {
    clear_spec();
    set_has_example_query_spec();
    _impl_.spec_.example_query_spec_ = CreateMaybeMessage< ::google::internal::federated::plan::ExampleQuerySpec >(GetArenaForAllocation());
  }
  return _impl_.spec_.example_query_spec_;
}
inline ::google::internal::federated::plan::ExampleQuerySpec* ClientPhase::mutable_example_query_spec() {
  ::google::internal::federated::plan::ExampleQuerySpec* _msg = _internal_mutable_example_query_spec();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ClientPhase.example_query_spec)
  return _msg;
}

// .google.internal.federated.plan.FederatedComputeIORouter federated_compute = 5 [lazy = true];
inline bool ClientPhase::_internal_has_federated_compute() const {
  return io_router_case() == kFederatedCompute;
}
inline bool ClientPhase::has_federated_compute() const {
  return _internal_has_federated_compute();
}
inline void ClientPhase::set_has_federated_compute() {
  _impl_._oneof_case_[1] = kFederatedCompute;
}
inline void ClientPhase::clear_federated_compute() {
  if (_internal_has_federated_compute()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.io_router_.federated_compute_;
    }
    clear_has_io_router();
  }
}
inline ::google::internal::federated::plan::FederatedComputeIORouter* ClientPhase::release_federated_compute() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ClientPhase.federated_compute)
  if (_internal_has_federated_compute()) {
    clear_has_io_router();
    ::google::internal::federated::plan::FederatedComputeIORouter* temp = _impl_.io_router_.federated_compute_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.io_router_.federated_compute_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::google::internal::federated::plan::FederatedComputeIORouter& ClientPhase::_internal_federated_compute() const {
  return _internal_has_federated_compute()
      ? *_impl_.io_router_.federated_compute_
      : reinterpret_cast< ::google::internal::federated::plan::FederatedComputeIORouter&>(::google::internal::federated::plan::_FederatedComputeIORouter_default_instance_);
}
inline const ::google::internal::federated::plan::FederatedComputeIORouter& ClientPhase::federated_compute() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ClientPhase.federated_compute)
  return _internal_federated_compute();
}
inline ::google::internal::federated::plan::FederatedComputeIORouter* ClientPhase::unsafe_arena_release_federated_compute() {
  // @@protoc_insertion_point(field_unsafe_arena_release:google.internal.federated.plan.ClientPhase.federated_compute)
  if (_internal_has_federated_compute()) {
    clear_has_io_router();
    ::google::internal::federated::plan::FederatedComputeIORouter* temp = _impl_.io_router_.federated_compute_;
    _impl_.io_router_.federated_compute_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ClientPhase::unsafe_arena_set_allocated_federated_compute(::google::internal::federated::plan::FederatedComputeIORouter* federated_compute) {
  clear_io_router();
  if (federated_compute) {
    set_has_federated_compute();
    _impl_.io_router_.federated_compute_ = federated_compute;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.ClientPhase.federated_compute)
}
inline ::google::internal::federated::plan::FederatedComputeIORouter* ClientPhase::_internal_mutable_federated_compute() {
  if (!_internal_has_federated_compute()) {
    clear_io_router();
    set_has_federated_compute();
    _impl_.io_router_.federated_compute_ = CreateMaybeMessage< ::google::internal::federated::plan::FederatedComputeIORouter >(GetArenaForAllocation());
  }
  return _impl_.io_router_.federated_compute_;
}
inline ::google::internal::federated::plan::FederatedComputeIORouter* ClientPhase::mutable_federated_compute() {
  ::google::internal::federated::plan::FederatedComputeIORouter* _msg = _internal_mutable_federated_compute();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ClientPhase.federated_compute)
  return _msg;
}

// .google.internal.federated.plan.LocalComputeIORouter local_compute = 6 [lazy = true];
inline bool ClientPhase::_internal_has_local_compute() const {
  return io_router_case() == kLocalCompute;
}
inline bool ClientPhase::has_local_compute() const {
  return _internal_has_local_compute();
}
inline void ClientPhase::set_has_local_compute() {
  _impl_._oneof_case_[1] = kLocalCompute;
}
inline void ClientPhase::clear_local_compute() {
  if (_internal_has_local_compute()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.io_router_.local_compute_;
    }
    clear_has_io_router();
  }
}
inline ::google::internal::federated::plan::LocalComputeIORouter* ClientPhase::release_local_compute() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ClientPhase.local_compute)
  if (_internal_has_local_compute()) {
    clear_has_io_router();
    ::google::internal::federated::plan::LocalComputeIORouter* temp = _impl_.io_router_.local_compute_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.io_router_.local_compute_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::google::internal::federated::plan::LocalComputeIORouter& ClientPhase::_internal_local_compute() const {
  return _internal_has_local_compute()
      ? *_impl_.io_router_.local_compute_
      : reinterpret_cast< ::google::internal::federated::plan::LocalComputeIORouter&>(::google::internal::federated::plan::_LocalComputeIORouter_default_instance_);
}
inline const ::google::internal::federated::plan::LocalComputeIORouter& ClientPhase::local_compute() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ClientPhase.local_compute)
  return _internal_local_compute();
}
inline ::google::internal::federated::plan::LocalComputeIORouter* ClientPhase::unsafe_arena_release_local_compute() {
  // @@protoc_insertion_point(field_unsafe_arena_release:google.internal.federated.plan.ClientPhase.local_compute)
  if (_internal_has_local_compute()) {
    clear_has_io_router();
    ::google::internal::federated::plan::LocalComputeIORouter* temp = _impl_.io_router_.local_compute_;
    _impl_.io_router_.local_compute_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ClientPhase::unsafe_arena_set_allocated_local_compute(::google::internal::federated::plan::LocalComputeIORouter* local_compute) {
  clear_io_router();
  if (local_compute) {
    set_has_local_compute();
    _impl_.io_router_.local_compute_ = local_compute;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.ClientPhase.local_compute)
}
inline ::google::internal::federated::plan::LocalComputeIORouter* ClientPhase::_internal_mutable_local_compute() {
  if (!_internal_has_local_compute()) {
    clear_io_router();
    set_has_local_compute();
    _impl_.io_router_.local_compute_ = CreateMaybeMessage< ::google::internal::federated::plan::LocalComputeIORouter >(GetArenaForAllocation());
  }
  return _impl_.io_router_.local_compute_;
}
inline ::google::internal::federated::plan::LocalComputeIORouter* ClientPhase::mutable_local_compute() {
  ::google::internal::federated::plan::LocalComputeIORouter* _msg = _internal_mutable_local_compute();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ClientPhase.local_compute)
  return _msg;
}

// .google.internal.federated.plan.FederatedComputeEligibilityIORouter federated_compute_eligibility = 7 [lazy = true];
inline bool ClientPhase::_internal_has_federated_compute_eligibility() const {
  return io_router_case() == kFederatedComputeEligibility;
}
inline bool ClientPhase::has_federated_compute_eligibility() const {
  return _internal_has_federated_compute_eligibility();
}
inline void ClientPhase::set_has_federated_compute_eligibility() {
  _impl_._oneof_case_[1] = kFederatedComputeEligibility;
}
inline void ClientPhase::clear_federated_compute_eligibility() {
  if (_internal_has_federated_compute_eligibility()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.io_router_.federated_compute_eligibility_;
    }
    clear_has_io_router();
  }
}
inline ::google::internal::federated::plan::FederatedComputeEligibilityIORouter* ClientPhase::release_federated_compute_eligibility() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ClientPhase.federated_compute_eligibility)
  if (_internal_has_federated_compute_eligibility()) {
    clear_has_io_router();
    ::google::internal::federated::plan::FederatedComputeEligibilityIORouter* temp = _impl_.io_router_.federated_compute_eligibility_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.io_router_.federated_compute_eligibility_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::google::internal::federated::plan::FederatedComputeEligibilityIORouter& ClientPhase::_internal_federated_compute_eligibility() const {
  return _internal_has_federated_compute_eligibility()
      ? *_impl_.io_router_.federated_compute_eligibility_
      : reinterpret_cast< ::google::internal::federated::plan::FederatedComputeEligibilityIORouter&>(::google::internal::federated::plan::_FederatedComputeEligibilityIORouter_default_instance_);
}
inline const ::google::internal::federated::plan::FederatedComputeEligibilityIORouter& ClientPhase::federated_compute_eligibility() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ClientPhase.federated_compute_eligibility)
  return _internal_federated_compute_eligibility();
}
inline ::google::internal::federated::plan::FederatedComputeEligibilityIORouter* ClientPhase::unsafe_arena_release_federated_compute_eligibility() {
  // @@protoc_insertion_point(field_unsafe_arena_release:google.internal.federated.plan.ClientPhase.federated_compute_eligibility)
  if (_internal_has_federated_compute_eligibility()) {
    clear_has_io_router();
    ::google::internal::federated::plan::FederatedComputeEligibilityIORouter* temp = _impl_.io_router_.federated_compute_eligibility_;
    _impl_.io_router_.federated_compute_eligibility_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ClientPhase::unsafe_arena_set_allocated_federated_compute_eligibility(::google::internal::federated::plan::FederatedComputeEligibilityIORouter* federated_compute_eligibility) {
  clear_io_router();
  if (federated_compute_eligibility) {
    set_has_federated_compute_eligibility();
    _impl_.io_router_.federated_compute_eligibility_ = federated_compute_eligibility;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.ClientPhase.federated_compute_eligibility)
}
inline ::google::internal::federated::plan::FederatedComputeEligibilityIORouter* ClientPhase::_internal_mutable_federated_compute_eligibility() {
  if (!_internal_has_federated_compute_eligibility()) {
    clear_io_router();
    set_has_federated_compute_eligibility();
    _impl_.io_router_.federated_compute_eligibility_ = CreateMaybeMessage< ::google::internal::federated::plan::FederatedComputeEligibilityIORouter >(GetArenaForAllocation());
  }
  return _impl_.io_router_.federated_compute_eligibility_;
}
inline ::google::internal::federated::plan::FederatedComputeEligibilityIORouter* ClientPhase::mutable_federated_compute_eligibility() {
  ::google::internal::federated::plan::FederatedComputeEligibilityIORouter* _msg = _internal_mutable_federated_compute_eligibility();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ClientPhase.federated_compute_eligibility)
  return _msg;
}

// .google.internal.federated.plan.FederatedExampleQueryIORouter federated_example_query = 8 [lazy = true];
inline bool ClientPhase::_internal_has_federated_example_query() const {
  return io_router_case() == kFederatedExampleQuery;
}
inline bool ClientPhase::has_federated_example_query() const {
  return _internal_has_federated_example_query();
}
inline void ClientPhase::set_has_federated_example_query() {
  _impl_._oneof_case_[1] = kFederatedExampleQuery;
}
inline void ClientPhase::clear_federated_example_query() {
  if (_internal_has_federated_example_query()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.io_router_.federated_example_query_;
    }
    clear_has_io_router();
  }
}
inline ::google::internal::federated::plan::FederatedExampleQueryIORouter* ClientPhase::release_federated_example_query() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ClientPhase.federated_example_query)
  if (_internal_has_federated_example_query()) {
    clear_has_io_router();
    ::google::internal::federated::plan::FederatedExampleQueryIORouter* temp = _impl_.io_router_.federated_example_query_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.io_router_.federated_example_query_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::google::internal::federated::plan::FederatedExampleQueryIORouter& ClientPhase::_internal_federated_example_query() const {
  return _internal_has_federated_example_query()
      ? *_impl_.io_router_.federated_example_query_
      : reinterpret_cast< ::google::internal::federated::plan::FederatedExampleQueryIORouter&>(::google::internal::federated::plan::_FederatedExampleQueryIORouter_default_instance_);
}
inline const ::google::internal::federated::plan::FederatedExampleQueryIORouter& ClientPhase::federated_example_query() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ClientPhase.federated_example_query)
  return _internal_federated_example_query();
}
inline ::google::internal::federated::plan::FederatedExampleQueryIORouter* ClientPhase::unsafe_arena_release_federated_example_query() {
  // @@protoc_insertion_point(field_unsafe_arena_release:google.internal.federated.plan.ClientPhase.federated_example_query)
  if (_internal_has_federated_example_query()) {
    clear_has_io_router();
    ::google::internal::federated::plan::FederatedExampleQueryIORouter* temp = _impl_.io_router_.federated_example_query_;
    _impl_.io_router_.federated_example_query_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ClientPhase::unsafe_arena_set_allocated_federated_example_query(::google::internal::federated::plan::FederatedExampleQueryIORouter* federated_example_query) {
  clear_io_router();
  if (federated_example_query) {
    set_has_federated_example_query();
    _impl_.io_router_.federated_example_query_ = federated_example_query;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.ClientPhase.federated_example_query)
}
inline ::google::internal::federated::plan::FederatedExampleQueryIORouter* ClientPhase::_internal_mutable_federated_example_query() {
  if (!_internal_has_federated_example_query()) {
    clear_io_router();
    set_has_federated_example_query();
    _impl_.io_router_.federated_example_query_ = CreateMaybeMessage< ::google::internal::federated::plan::FederatedExampleQueryIORouter >(GetArenaForAllocation());
  }
  return _impl_.io_router_.federated_example_query_;
}
inline ::google::internal::federated::plan::FederatedExampleQueryIORouter* ClientPhase::mutable_federated_example_query() {
  ::google::internal::federated::plan::FederatedExampleQueryIORouter* _msg = _internal_mutable_federated_example_query();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ClientPhase.federated_example_query)
  return _msg;
}

inline bool ClientPhase::has_spec() const {
  return spec_case() != SPEC_NOT_SET;
}
inline void ClientPhase::clear_has_spec() {
  _impl_._oneof_case_[0] = SPEC_NOT_SET;
}
inline bool ClientPhase::has_io_router() const {
  return io_router_case() != IO_ROUTER_NOT_SET;
}
inline void ClientPhase::clear_has_io_router() {
  _impl_._oneof_case_[1] = IO_ROUTER_NOT_SET;
}
inline ClientPhase::SpecCase ClientPhase::spec_case() const {
  return ClientPhase::SpecCase(_impl_._oneof_case_[0]);
}
inline ClientPhase::IoRouterCase ClientPhase::io_router_case() const {
  return ClientPhase::IoRouterCase(_impl_._oneof_case_[1]);
}
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// TensorflowSpec

// string dataset_token_tensor_name = 1;
inline void TensorflowSpec::clear_dataset_token_tensor_name() {
  _impl_.dataset_token_tensor_name_.ClearToEmpty();
}
inline const std::string& TensorflowSpec::dataset_token_tensor_name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.TensorflowSpec.dataset_token_tensor_name)
  return _internal_dataset_token_tensor_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void TensorflowSpec::set_dataset_token_tensor_name(ArgT0&& arg0, ArgT... args) {

 _impl_.dataset_token_tensor_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.TensorflowSpec.dataset_token_tensor_name)
}
inline std::string* TensorflowSpec::mutable_dataset_token_tensor_name() {
  std::string* _s = _internal_mutable_dataset_token_tensor_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.TensorflowSpec.dataset_token_tensor_name)
  return _s;
}
inline const std::string& TensorflowSpec::_internal_dataset_token_tensor_name() const {
  return _impl_.dataset_token_tensor_name_.Get();
}
inline void TensorflowSpec::_internal_set_dataset_token_tensor_name(const std::string& value) {

  _impl_.dataset_token_tensor_name_.Set(value, GetArenaForAllocation());
}
inline std::string* TensorflowSpec::_internal_mutable_dataset_token_tensor_name() {

  return _impl_.dataset_token_tensor_name_.Mutable(GetArenaForAllocation());
}
inline std::string* TensorflowSpec::release_dataset_token_tensor_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.TensorflowSpec.dataset_token_tensor_name)
  return _impl_.dataset_token_tensor_name_.Release();
}
inline void TensorflowSpec::set_allocated_dataset_token_tensor_name(std::string* dataset_token_tensor_name) {
  _impl_.dataset_token_tensor_name_.SetAllocated(dataset_token_tensor_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.dataset_token_tensor_name_.IsDefault()) {
    _impl_.dataset_token_tensor_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.TensorflowSpec.dataset_token_tensor_name)
}

// repeated .tensorflow.TensorSpecProto input_tensor_specs = 2;
inline int TensorflowSpec::_internal_input_tensor_specs_size() const {
  return _impl_.input_tensor_specs_.size();
}
inline int TensorflowSpec::input_tensor_specs_size() const {
  return _internal_input_tensor_specs_size();
}
inline ::tensorflow::TensorSpecProto* TensorflowSpec::mutable_input_tensor_specs(int index) {
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.TensorflowSpec.input_tensor_specs)
  return _impl_.input_tensor_specs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorSpecProto >*
TensorflowSpec::mutable_input_tensor_specs() {
  // @@protoc_insertion_point(field_mutable_list:google.internal.federated.plan.TensorflowSpec.input_tensor_specs)
  return &_impl_.input_tensor_specs_;
}
inline const ::tensorflow::TensorSpecProto& TensorflowSpec::_internal_input_tensor_specs(int index) const {
  return _impl_.input_tensor_specs_.Get(index);
}
inline const ::tensorflow::TensorSpecProto& TensorflowSpec::input_tensor_specs(int index) const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.TensorflowSpec.input_tensor_specs)
  return _internal_input_tensor_specs(index);
}
inline ::tensorflow::TensorSpecProto* TensorflowSpec::_internal_add_input_tensor_specs() {
  return _impl_.input_tensor_specs_.Add();
}
inline ::tensorflow::TensorSpecProto* TensorflowSpec::add_input_tensor_specs() {
  ::tensorflow::TensorSpecProto* _add = _internal_add_input_tensor_specs();
  // @@protoc_insertion_point(field_add:google.internal.federated.plan.TensorflowSpec.input_tensor_specs)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorSpecProto >&
TensorflowSpec::input_tensor_specs() const {
  // @@protoc_insertion_point(field_list:google.internal.federated.plan.TensorflowSpec.input_tensor_specs)
  return _impl_.input_tensor_specs_;
}

// repeated .tensorflow.TensorSpecProto output_tensor_specs = 3;
inline int TensorflowSpec::_internal_output_tensor_specs_size() const {
  return _impl_.output_tensor_specs_.size();
}
inline int TensorflowSpec::output_tensor_specs_size() const {
  return _internal_output_tensor_specs_size();
}
inline ::tensorflow::TensorSpecProto* TensorflowSpec::mutable_output_tensor_specs(int index) {
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.TensorflowSpec.output_tensor_specs)
  return _impl_.output_tensor_specs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorSpecProto >*
TensorflowSpec::mutable_output_tensor_specs() {
  // @@protoc_insertion_point(field_mutable_list:google.internal.federated.plan.TensorflowSpec.output_tensor_specs)
  return &_impl_.output_tensor_specs_;
}
inline const ::tensorflow::TensorSpecProto& TensorflowSpec::_internal_output_tensor_specs(int index) const {
  return _impl_.output_tensor_specs_.Get(index);
}
inline const ::tensorflow::TensorSpecProto& TensorflowSpec::output_tensor_specs(int index) const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.TensorflowSpec.output_tensor_specs)
  return _internal_output_tensor_specs(index);
}
inline ::tensorflow::TensorSpecProto* TensorflowSpec::_internal_add_output_tensor_specs() {
  return _impl_.output_tensor_specs_.Add();
}
inline ::tensorflow::TensorSpecProto* TensorflowSpec::add_output_tensor_specs() {
  ::tensorflow::TensorSpecProto* _add = _internal_add_output_tensor_specs();
  // @@protoc_insertion_point(field_add:google.internal.federated.plan.TensorflowSpec.output_tensor_specs)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorSpecProto >&
TensorflowSpec::output_tensor_specs() const {
  // @@protoc_insertion_point(field_list:google.internal.federated.plan.TensorflowSpec.output_tensor_specs)
  return _impl_.output_tensor_specs_;
}

// repeated string target_node_names = 4;
inline int TensorflowSpec::_internal_target_node_names_size() const {
  return _impl_.target_node_names_.size();
}
inline int TensorflowSpec::target_node_names_size() const {
  return _internal_target_node_names_size();
}
inline void TensorflowSpec::clear_target_node_names() {
  _impl_.target_node_names_.Clear();
}
inline std::string* TensorflowSpec::add_target_node_names() {
  std::string* _s = _internal_add_target_node_names();
  // @@protoc_insertion_point(field_add_mutable:google.internal.federated.plan.TensorflowSpec.target_node_names)
  return _s;
}
inline const std::string& TensorflowSpec::_internal_target_node_names(int index) const {
  return _impl_.target_node_names_.Get(index);
}
inline const std::string& TensorflowSpec::target_node_names(int index) const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.TensorflowSpec.target_node_names)
  return _internal_target_node_names(index);
}
inline std::string* TensorflowSpec::mutable_target_node_names(int index) {
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.TensorflowSpec.target_node_names)
  return _impl_.target_node_names_.Mutable(index);
}
inline void TensorflowSpec::set_target_node_names(int index, const std::string& value) {
  _impl_.target_node_names_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.TensorflowSpec.target_node_names)
}
inline void TensorflowSpec::set_target_node_names(int index, std::string&& value) {
  _impl_.target_node_names_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.TensorflowSpec.target_node_names)
}
inline void TensorflowSpec::set_target_node_names(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.target_node_names_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:google.internal.federated.plan.TensorflowSpec.target_node_names)
}
inline void TensorflowSpec::set_target_node_names(int index, const char* value, size_t size) {
  _impl_.target_node_names_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:google.internal.federated.plan.TensorflowSpec.target_node_names)
}
inline std::string* TensorflowSpec::_internal_add_target_node_names() {
  return _impl_.target_node_names_.Add();
}
inline void TensorflowSpec::add_target_node_names(const std::string& value) {
  _impl_.target_node_names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:google.internal.federated.plan.TensorflowSpec.target_node_names)
}
inline void TensorflowSpec::add_target_node_names(std::string&& value) {
  _impl_.target_node_names_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:google.internal.federated.plan.TensorflowSpec.target_node_names)
}
inline void TensorflowSpec::add_target_node_names(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.target_node_names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:google.internal.federated.plan.TensorflowSpec.target_node_names)
}
inline void TensorflowSpec::add_target_node_names(const char* value, size_t size) {
  _impl_.target_node_names_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:google.internal.federated.plan.TensorflowSpec.target_node_names)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
TensorflowSpec::target_node_names() const {
  // @@protoc_insertion_point(field_list:google.internal.federated.plan.TensorflowSpec.target_node_names)
  return _impl_.target_node_names_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
TensorflowSpec::mutable_target_node_names() {
  // @@protoc_insertion_point(field_mutable_list:google.internal.federated.plan.TensorflowSpec.target_node_names)
  return &_impl_.target_node_names_;
}

// map<string, .tensorflow.TensorProto> constant_inputs = 5;
inline int TensorflowSpec::_internal_constant_inputs_size() const {
  return _impl_.constant_inputs_.size();
}
inline int TensorflowSpec::constant_inputs_size() const {
  return _internal_constant_inputs_size();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::TensorProto >&
TensorflowSpec::_internal_constant_inputs() const {
  return _impl_.constant_inputs_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::TensorProto >&
TensorflowSpec::constant_inputs() const {
  // @@protoc_insertion_point(field_map:google.internal.federated.plan.TensorflowSpec.constant_inputs)
  return _internal_constant_inputs();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::TensorProto >*
TensorflowSpec::_internal_mutable_constant_inputs() {
  return _impl_.constant_inputs_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::TensorProto >*
TensorflowSpec::mutable_constant_inputs() {
  // @@protoc_insertion_point(field_mutable_map:google.internal.federated.plan.TensorflowSpec.constant_inputs)
  return _internal_mutable_constant_inputs();
}

// .google.internal.federated.plan.ExampleSelector example_selector = 999;
inline bool TensorflowSpec::_internal_has_example_selector() const {
  return this != internal_default_instance() && _impl_.example_selector_ != nullptr;
}
inline bool TensorflowSpec::has_example_selector() const {
  return _internal_has_example_selector();
}
inline void TensorflowSpec::clear_example_selector() {
  if (GetArenaForAllocation() == nullptr && _impl_.example_selector_ != nullptr) {
    delete _impl_.example_selector_;
  }
  _impl_.example_selector_ = nullptr;
}
inline const ::google::internal::federated::plan::ExampleSelector& TensorflowSpec::_internal_example_selector() const {
  const ::google::internal::federated::plan::ExampleSelector* p = _impl_.example_selector_;
  return p != nullptr ? *p : reinterpret_cast<const ::google::internal::federated::plan::ExampleSelector&>(
      ::google::internal::federated::plan::_ExampleSelector_default_instance_);
}
inline const ::google::internal::federated::plan::ExampleSelector& TensorflowSpec::example_selector() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.TensorflowSpec.example_selector)
  return _internal_example_selector();
}
inline void TensorflowSpec::unsafe_arena_set_allocated_example_selector(
    ::google::internal::federated::plan::ExampleSelector* example_selector) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.example_selector_);
  }
  _impl_.example_selector_ = example_selector;
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.TensorflowSpec.example_selector)
}
inline ::google::internal::federated::plan::ExampleSelector* TensorflowSpec::release_example_selector() {

  ::google::internal::federated::plan::ExampleSelector* temp = _impl_.example_selector_;
  _impl_.example_selector_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::google::internal::federated::plan::ExampleSelector* TensorflowSpec::unsafe_arena_release_example_selector() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.TensorflowSpec.example_selector)

  ::google::internal::federated::plan::ExampleSelector* temp = _impl_.example_selector_;
  _impl_.example_selector_ = nullptr;
  return temp;
}
inline ::google::internal::federated::plan::ExampleSelector* TensorflowSpec::_internal_mutable_example_selector() {

  if (_impl_.example_selector_ == nullptr) {
    auto* p = CreateMaybeMessage<::google::internal::federated::plan::ExampleSelector>(GetArenaForAllocation());
    _impl_.example_selector_ = p;
  }
  return _impl_.example_selector_;
}
inline ::google::internal::federated::plan::ExampleSelector* TensorflowSpec::mutable_example_selector() {
  ::google::internal::federated::plan::ExampleSelector* _msg = _internal_mutable_example_selector();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.TensorflowSpec.example_selector)
  return _msg;
}
inline void TensorflowSpec::set_allocated_example_selector(::google::internal::federated::plan::ExampleSelector* example_selector) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.example_selector_;
  }
  if (example_selector) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(example_selector);
    if (message_arena != submessage_arena) {
      example_selector = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, example_selector, submessage_arena);
    }

  } else {

  }
  _impl_.example_selector_ = example_selector;
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.TensorflowSpec.example_selector)
}

// -------------------------------------------------------------------

// ExampleQuerySpec_OutputVectorSpec

// string vector_name = 1;
inline void ExampleQuerySpec_OutputVectorSpec::clear_vector_name() {
  _impl_.vector_name_.ClearToEmpty();
}
inline const std::string& ExampleQuerySpec_OutputVectorSpec::vector_name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ExampleQuerySpec.OutputVectorSpec.vector_name)
  return _internal_vector_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ExampleQuerySpec_OutputVectorSpec::set_vector_name(ArgT0&& arg0, ArgT... args) {

 _impl_.vector_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.ExampleQuerySpec.OutputVectorSpec.vector_name)
}
inline std::string* ExampleQuerySpec_OutputVectorSpec::mutable_vector_name() {
  std::string* _s = _internal_mutable_vector_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ExampleQuerySpec.OutputVectorSpec.vector_name)
  return _s;
}
inline const std::string& ExampleQuerySpec_OutputVectorSpec::_internal_vector_name() const {
  return _impl_.vector_name_.Get();
}
inline void ExampleQuerySpec_OutputVectorSpec::_internal_set_vector_name(const std::string& value) {

  _impl_.vector_name_.Set(value, GetArenaForAllocation());
}
inline std::string* ExampleQuerySpec_OutputVectorSpec::_internal_mutable_vector_name() {

  return _impl_.vector_name_.Mutable(GetArenaForAllocation());
}
inline std::string* ExampleQuerySpec_OutputVectorSpec::release_vector_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ExampleQuerySpec.OutputVectorSpec.vector_name)
  return _impl_.vector_name_.Release();
}
inline void ExampleQuerySpec_OutputVectorSpec::set_allocated_vector_name(std::string* vector_name) {
  _impl_.vector_name_.SetAllocated(vector_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.vector_name_.IsDefault()) {
    _impl_.vector_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ExampleQuerySpec.OutputVectorSpec.vector_name)
}

// .google.internal.federated.plan.ExampleQuerySpec.OutputVectorSpec.DataType data_type = 2;
inline void ExampleQuerySpec_OutputVectorSpec::clear_data_type() {
  _impl_.data_type_ = 0;
}
inline ::google::internal::federated::plan::ExampleQuerySpec_OutputVectorSpec_DataType ExampleQuerySpec_OutputVectorSpec::_internal_data_type() const {
  return static_cast< ::google::internal::federated::plan::ExampleQuerySpec_OutputVectorSpec_DataType >(_impl_.data_type_);
}
inline ::google::internal::federated::plan::ExampleQuerySpec_OutputVectorSpec_DataType ExampleQuerySpec_OutputVectorSpec::data_type() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ExampleQuerySpec.OutputVectorSpec.data_type)
  return _internal_data_type();
}
inline void ExampleQuerySpec_OutputVectorSpec::_internal_set_data_type(::google::internal::federated::plan::ExampleQuerySpec_OutputVectorSpec_DataType value) {

  _impl_.data_type_ = value;
}
inline void ExampleQuerySpec_OutputVectorSpec::set_data_type(::google::internal::federated::plan::ExampleQuerySpec_OutputVectorSpec_DataType value) {
  _internal_set_data_type(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.ExampleQuerySpec.OutputVectorSpec.data_type)
}

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// ExampleQuerySpec_ExampleQuery

// .google.internal.federated.plan.ExampleSelector example_selector = 1;
inline bool ExampleQuerySpec_ExampleQuery::_internal_has_example_selector() const {
  return this != internal_default_instance() && _impl_.example_selector_ != nullptr;
}
inline bool ExampleQuerySpec_ExampleQuery::has_example_selector() const {
  return _internal_has_example_selector();
}
inline void ExampleQuerySpec_ExampleQuery::clear_example_selector() {
  if (GetArenaForAllocation() == nullptr && _impl_.example_selector_ != nullptr) {
    delete _impl_.example_selector_;
  }
  _impl_.example_selector_ = nullptr;
}
inline const ::google::internal::federated::plan::ExampleSelector& ExampleQuerySpec_ExampleQuery::_internal_example_selector() const {
  const ::google::internal::federated::plan::ExampleSelector* p = _impl_.example_selector_;
  return p != nullptr ? *p : reinterpret_cast<const ::google::internal::federated::plan::ExampleSelector&>(
      ::google::internal::federated::plan::_ExampleSelector_default_instance_);
}
inline const ::google::internal::federated::plan::ExampleSelector& ExampleQuerySpec_ExampleQuery::example_selector() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ExampleQuerySpec.ExampleQuery.example_selector)
  return _internal_example_selector();
}
inline void ExampleQuerySpec_ExampleQuery::unsafe_arena_set_allocated_example_selector(
    ::google::internal::federated::plan::ExampleSelector* example_selector) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.example_selector_);
  }
  _impl_.example_selector_ = example_selector;
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.ExampleQuerySpec.ExampleQuery.example_selector)
}
inline ::google::internal::federated::plan::ExampleSelector* ExampleQuerySpec_ExampleQuery::release_example_selector() {

  ::google::internal::federated::plan::ExampleSelector* temp = _impl_.example_selector_;
  _impl_.example_selector_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::google::internal::federated::plan::ExampleSelector* ExampleQuerySpec_ExampleQuery::unsafe_arena_release_example_selector() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ExampleQuerySpec.ExampleQuery.example_selector)

  ::google::internal::federated::plan::ExampleSelector* temp = _impl_.example_selector_;
  _impl_.example_selector_ = nullptr;
  return temp;
}
inline ::google::internal::federated::plan::ExampleSelector* ExampleQuerySpec_ExampleQuery::_internal_mutable_example_selector() {

  if (_impl_.example_selector_ == nullptr) {
    auto* p = CreateMaybeMessage<::google::internal::federated::plan::ExampleSelector>(GetArenaForAllocation());
    _impl_.example_selector_ = p;
  }
  return _impl_.example_selector_;
}
inline ::google::internal::federated::plan::ExampleSelector* ExampleQuerySpec_ExampleQuery::mutable_example_selector() {
  ::google::internal::federated::plan::ExampleSelector* _msg = _internal_mutable_example_selector();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ExampleQuerySpec.ExampleQuery.example_selector)
  return _msg;
}
inline void ExampleQuerySpec_ExampleQuery::set_allocated_example_selector(::google::internal::federated::plan::ExampleSelector* example_selector) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.example_selector_;
  }
  if (example_selector) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(example_selector);
    if (message_arena != submessage_arena) {
      example_selector = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, example_selector, submessage_arena);
    }

  } else {

  }
  _impl_.example_selector_ = example_selector;
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ExampleQuerySpec.ExampleQuery.example_selector)
}

// map<string, .google.internal.federated.plan.ExampleQuerySpec.OutputVectorSpec> output_vector_specs = 2;
inline int ExampleQuerySpec_ExampleQuery::_internal_output_vector_specs_size() const {
  return _impl_.output_vector_specs_.size();
}
inline int ExampleQuerySpec_ExampleQuery::output_vector_specs_size() const {
  return _internal_output_vector_specs_size();
}
inline void ExampleQuerySpec_ExampleQuery::clear_output_vector_specs() {
  _impl_.output_vector_specs_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::ExampleQuerySpec_OutputVectorSpec >&
ExampleQuerySpec_ExampleQuery::_internal_output_vector_specs() const {
  return _impl_.output_vector_specs_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::ExampleQuerySpec_OutputVectorSpec >&
ExampleQuerySpec_ExampleQuery::output_vector_specs() const {
  // @@protoc_insertion_point(field_map:google.internal.federated.plan.ExampleQuerySpec.ExampleQuery.output_vector_specs)
  return _internal_output_vector_specs();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::ExampleQuerySpec_OutputVectorSpec >*
ExampleQuerySpec_ExampleQuery::_internal_mutable_output_vector_specs() {
  return _impl_.output_vector_specs_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::ExampleQuerySpec_OutputVectorSpec >*
ExampleQuerySpec_ExampleQuery::mutable_output_vector_specs() {
  // @@protoc_insertion_point(field_mutable_map:google.internal.federated.plan.ExampleQuerySpec.ExampleQuery.output_vector_specs)
  return _internal_mutable_output_vector_specs();
}

// -------------------------------------------------------------------

// ExampleQuerySpec

// repeated .google.internal.federated.plan.ExampleQuerySpec.ExampleQuery example_queries = 1;
inline int ExampleQuerySpec::_internal_example_queries_size() const {
  return _impl_.example_queries_.size();
}
inline int ExampleQuerySpec::example_queries_size() const {
  return _internal_example_queries_size();
}
inline void ExampleQuerySpec::clear_example_queries() {
  _impl_.example_queries_.Clear();
}
inline ::google::internal::federated::plan::ExampleQuerySpec_ExampleQuery* ExampleQuerySpec::mutable_example_queries(int index) {
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ExampleQuerySpec.example_queries)
  return _impl_.example_queries_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::ExampleQuerySpec_ExampleQuery >*
ExampleQuerySpec::mutable_example_queries() {
  // @@protoc_insertion_point(field_mutable_list:google.internal.federated.plan.ExampleQuerySpec.example_queries)
  return &_impl_.example_queries_;
}
inline const ::google::internal::federated::plan::ExampleQuerySpec_ExampleQuery& ExampleQuerySpec::_internal_example_queries(int index) const {
  return _impl_.example_queries_.Get(index);
}
inline const ::google::internal::federated::plan::ExampleQuerySpec_ExampleQuery& ExampleQuerySpec::example_queries(int index) const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ExampleQuerySpec.example_queries)
  return _internal_example_queries(index);
}
inline ::google::internal::federated::plan::ExampleQuerySpec_ExampleQuery* ExampleQuerySpec::_internal_add_example_queries() {
  return _impl_.example_queries_.Add();
}
inline ::google::internal::federated::plan::ExampleQuerySpec_ExampleQuery* ExampleQuerySpec::add_example_queries() {
  ::google::internal::federated::plan::ExampleQuerySpec_ExampleQuery* _add = _internal_add_example_queries();
  // @@protoc_insertion_point(field_add:google.internal.federated.plan.ExampleQuerySpec.example_queries)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::ExampleQuerySpec_ExampleQuery >&
ExampleQuerySpec::example_queries() const {
  // @@protoc_insertion_point(field_list:google.internal.federated.plan.ExampleQuerySpec.example_queries)
  return _impl_.example_queries_;
}

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// FederatedComputeIORouter

// string input_filepath_tensor_name = 1;
inline void FederatedComputeIORouter::clear_input_filepath_tensor_name() {
  _impl_.input_filepath_tensor_name_.ClearToEmpty();
}
inline const std::string& FederatedComputeIORouter::input_filepath_tensor_name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.FederatedComputeIORouter.input_filepath_tensor_name)
  return _internal_input_filepath_tensor_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void FederatedComputeIORouter::set_input_filepath_tensor_name(ArgT0&& arg0, ArgT... args) {

 _impl_.input_filepath_tensor_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.FederatedComputeIORouter.input_filepath_tensor_name)
}
inline std::string* FederatedComputeIORouter::mutable_input_filepath_tensor_name() {
  std::string* _s = _internal_mutable_input_filepath_tensor_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.FederatedComputeIORouter.input_filepath_tensor_name)
  return _s;
}
inline const std::string& FederatedComputeIORouter::_internal_input_filepath_tensor_name() const {
  return _impl_.input_filepath_tensor_name_.Get();
}
inline void FederatedComputeIORouter::_internal_set_input_filepath_tensor_name(const std::string& value) {

  _impl_.input_filepath_tensor_name_.Set(value, GetArenaForAllocation());
}
inline std::string* FederatedComputeIORouter::_internal_mutable_input_filepath_tensor_name() {

  return _impl_.input_filepath_tensor_name_.Mutable(GetArenaForAllocation());
}
inline std::string* FederatedComputeIORouter::release_input_filepath_tensor_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.FederatedComputeIORouter.input_filepath_tensor_name)
  return _impl_.input_filepath_tensor_name_.Release();
}
inline void FederatedComputeIORouter::set_allocated_input_filepath_tensor_name(std::string* input_filepath_tensor_name) {
  _impl_.input_filepath_tensor_name_.SetAllocated(input_filepath_tensor_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.input_filepath_tensor_name_.IsDefault()) {
    _impl_.input_filepath_tensor_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.FederatedComputeIORouter.input_filepath_tensor_name)
}

// string output_filepath_tensor_name = 2;
inline void FederatedComputeIORouter::clear_output_filepath_tensor_name() {
  _impl_.output_filepath_tensor_name_.ClearToEmpty();
}
inline const std::string& FederatedComputeIORouter::output_filepath_tensor_name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.FederatedComputeIORouter.output_filepath_tensor_name)
  return _internal_output_filepath_tensor_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void FederatedComputeIORouter::set_output_filepath_tensor_name(ArgT0&& arg0, ArgT... args) {

 _impl_.output_filepath_tensor_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.FederatedComputeIORouter.output_filepath_tensor_name)
}
inline std::string* FederatedComputeIORouter::mutable_output_filepath_tensor_name() {
  std::string* _s = _internal_mutable_output_filepath_tensor_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.FederatedComputeIORouter.output_filepath_tensor_name)
  return _s;
}
inline const std::string& FederatedComputeIORouter::_internal_output_filepath_tensor_name() const {
  return _impl_.output_filepath_tensor_name_.Get();
}
inline void FederatedComputeIORouter::_internal_set_output_filepath_tensor_name(const std::string& value) {

  _impl_.output_filepath_tensor_name_.Set(value, GetArenaForAllocation());
}
inline std::string* FederatedComputeIORouter::_internal_mutable_output_filepath_tensor_name() {

  return _impl_.output_filepath_tensor_name_.Mutable(GetArenaForAllocation());
}
inline std::string* FederatedComputeIORouter::release_output_filepath_tensor_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.FederatedComputeIORouter.output_filepath_tensor_name)
  return _impl_.output_filepath_tensor_name_.Release();
}
inline void FederatedComputeIORouter::set_allocated_output_filepath_tensor_name(std::string* output_filepath_tensor_name) {
  _impl_.output_filepath_tensor_name_.SetAllocated(output_filepath_tensor_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.output_filepath_tensor_name_.IsDefault()) {
    _impl_.output_filepath_tensor_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.FederatedComputeIORouter.output_filepath_tensor_name)
}

// map<string, .google.internal.federated.plan.AggregationConfig> aggregations = 3;
inline int FederatedComputeIORouter::_internal_aggregations_size() const {
  return _impl_.aggregations_.size();
}
inline int FederatedComputeIORouter::aggregations_size() const {
  return _internal_aggregations_size();
}
inline void FederatedComputeIORouter::clear_aggregations() {
  _impl_.aggregations_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::AggregationConfig >&
FederatedComputeIORouter::_internal_aggregations() const {
  return _impl_.aggregations_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::AggregationConfig >&
FederatedComputeIORouter::aggregations() const {
  // @@protoc_insertion_point(field_map:google.internal.federated.plan.FederatedComputeIORouter.aggregations)
  return _internal_aggregations();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::AggregationConfig >*
FederatedComputeIORouter::_internal_mutable_aggregations() {
  return _impl_.aggregations_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::AggregationConfig >*
FederatedComputeIORouter::mutable_aggregations() {
  // @@protoc_insertion_point(field_mutable_map:google.internal.federated.plan.FederatedComputeIORouter.aggregations)
  return _internal_mutable_aggregations();
}

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// FederatedExampleQueryIORouter

// map<string, .google.internal.federated.plan.AggregationConfig> aggregations = 1;
inline int FederatedExampleQueryIORouter::_internal_aggregations_size() const {
  return _impl_.aggregations_.size();
}
inline int FederatedExampleQueryIORouter::aggregations_size() const {
  return _internal_aggregations_size();
}
inline void FederatedExampleQueryIORouter::clear_aggregations() {
  _impl_.aggregations_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::AggregationConfig >&
FederatedExampleQueryIORouter::_internal_aggregations() const {
  return _impl_.aggregations_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::AggregationConfig >&
FederatedExampleQueryIORouter::aggregations() const {
  // @@protoc_insertion_point(field_map:google.internal.federated.plan.FederatedExampleQueryIORouter.aggregations)
  return _internal_aggregations();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::AggregationConfig >*
FederatedExampleQueryIORouter::_internal_mutable_aggregations() {
  return _impl_.aggregations_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::AggregationConfig >*
FederatedExampleQueryIORouter::mutable_aggregations() {
  // @@protoc_insertion_point(field_mutable_map:google.internal.federated.plan.FederatedExampleQueryIORouter.aggregations)
  return _internal_mutable_aggregations();
}

// -------------------------------------------------------------------

// AggregationConfig

// .google.internal.federated.plan.SecureAggregationConfig secure_aggregation = 2;
inline bool AggregationConfig::_internal_has_secure_aggregation() const {
  return protocol_config_case() == kSecureAggregation;
}
inline bool AggregationConfig::has_secure_aggregation() const {
  return _internal_has_secure_aggregation();
}
inline void AggregationConfig::set_has_secure_aggregation() {
  _impl_._oneof_case_[0] = kSecureAggregation;
}
inline void AggregationConfig::clear_secure_aggregation() {
  if (_internal_has_secure_aggregation()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.protocol_config_.secure_aggregation_;
    }
    clear_has_protocol_config();
  }
}
inline ::google::internal::federated::plan::SecureAggregationConfig* AggregationConfig::release_secure_aggregation() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.AggregationConfig.secure_aggregation)
  if (_internal_has_secure_aggregation()) {
    clear_has_protocol_config();
    ::google::internal::federated::plan::SecureAggregationConfig* temp = _impl_.protocol_config_.secure_aggregation_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.protocol_config_.secure_aggregation_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::google::internal::federated::plan::SecureAggregationConfig& AggregationConfig::_internal_secure_aggregation() const {
  return _internal_has_secure_aggregation()
      ? *_impl_.protocol_config_.secure_aggregation_
      : reinterpret_cast< ::google::internal::federated::plan::SecureAggregationConfig&>(::google::internal::federated::plan::_SecureAggregationConfig_default_instance_);
}
inline const ::google::internal::federated::plan::SecureAggregationConfig& AggregationConfig::secure_aggregation() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.AggregationConfig.secure_aggregation)
  return _internal_secure_aggregation();
}
inline ::google::internal::federated::plan::SecureAggregationConfig* AggregationConfig::unsafe_arena_release_secure_aggregation() {
  // @@protoc_insertion_point(field_unsafe_arena_release:google.internal.federated.plan.AggregationConfig.secure_aggregation)
  if (_internal_has_secure_aggregation()) {
    clear_has_protocol_config();
    ::google::internal::federated::plan::SecureAggregationConfig* temp = _impl_.protocol_config_.secure_aggregation_;
    _impl_.protocol_config_.secure_aggregation_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void AggregationConfig::unsafe_arena_set_allocated_secure_aggregation(::google::internal::federated::plan::SecureAggregationConfig* secure_aggregation) {
  clear_protocol_config();
  if (secure_aggregation) {
    set_has_secure_aggregation();
    _impl_.protocol_config_.secure_aggregation_ = secure_aggregation;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.AggregationConfig.secure_aggregation)
}
inline ::google::internal::federated::plan::SecureAggregationConfig* AggregationConfig::_internal_mutable_secure_aggregation() {
  if (!_internal_has_secure_aggregation()) {
    clear_protocol_config();
    set_has_secure_aggregation();
    _impl_.protocol_config_.secure_aggregation_ = CreateMaybeMessage< ::google::internal::federated::plan::SecureAggregationConfig >(GetArenaForAllocation());
  }
  return _impl_.protocol_config_.secure_aggregation_;
}
inline ::google::internal::federated::plan::SecureAggregationConfig* AggregationConfig::mutable_secure_aggregation() {
  ::google::internal::federated::plan::SecureAggregationConfig* _msg = _internal_mutable_secure_aggregation();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.AggregationConfig.secure_aggregation)
  return _msg;
}

// .google.internal.federated.plan.TFV1CheckpointAggregation tf_v1_checkpoint_aggregation = 3;
inline bool AggregationConfig::_internal_has_tf_v1_checkpoint_aggregation() const {
  return protocol_config_case() == kTfV1CheckpointAggregation;
}
inline bool AggregationConfig::has_tf_v1_checkpoint_aggregation() const {
  return _internal_has_tf_v1_checkpoint_aggregation();
}
inline void AggregationConfig::set_has_tf_v1_checkpoint_aggregation() {
  _impl_._oneof_case_[0] = kTfV1CheckpointAggregation;
}
inline void AggregationConfig::clear_tf_v1_checkpoint_aggregation() {
  if (_internal_has_tf_v1_checkpoint_aggregation()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.protocol_config_.tf_v1_checkpoint_aggregation_;
    }
    clear_has_protocol_config();
  }
}
inline ::google::internal::federated::plan::TFV1CheckpointAggregation* AggregationConfig::release_tf_v1_checkpoint_aggregation() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.AggregationConfig.tf_v1_checkpoint_aggregation)
  if (_internal_has_tf_v1_checkpoint_aggregation()) {
    clear_has_protocol_config();
    ::google::internal::federated::plan::TFV1CheckpointAggregation* temp = _impl_.protocol_config_.tf_v1_checkpoint_aggregation_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.protocol_config_.tf_v1_checkpoint_aggregation_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::google::internal::federated::plan::TFV1CheckpointAggregation& AggregationConfig::_internal_tf_v1_checkpoint_aggregation() const {
  return _internal_has_tf_v1_checkpoint_aggregation()
      ? *_impl_.protocol_config_.tf_v1_checkpoint_aggregation_
      : reinterpret_cast< ::google::internal::federated::plan::TFV1CheckpointAggregation&>(::google::internal::federated::plan::_TFV1CheckpointAggregation_default_instance_);
}
inline const ::google::internal::federated::plan::TFV1CheckpointAggregation& AggregationConfig::tf_v1_checkpoint_aggregation() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.AggregationConfig.tf_v1_checkpoint_aggregation)
  return _internal_tf_v1_checkpoint_aggregation();
}
inline ::google::internal::federated::plan::TFV1CheckpointAggregation* AggregationConfig::unsafe_arena_release_tf_v1_checkpoint_aggregation() {
  // @@protoc_insertion_point(field_unsafe_arena_release:google.internal.federated.plan.AggregationConfig.tf_v1_checkpoint_aggregation)
  if (_internal_has_tf_v1_checkpoint_aggregation()) {
    clear_has_protocol_config();
    ::google::internal::federated::plan::TFV1CheckpointAggregation* temp = _impl_.protocol_config_.tf_v1_checkpoint_aggregation_;
    _impl_.protocol_config_.tf_v1_checkpoint_aggregation_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void AggregationConfig::unsafe_arena_set_allocated_tf_v1_checkpoint_aggregation(::google::internal::federated::plan::TFV1CheckpointAggregation* tf_v1_checkpoint_aggregation) {
  clear_protocol_config();
  if (tf_v1_checkpoint_aggregation) {
    set_has_tf_v1_checkpoint_aggregation();
    _impl_.protocol_config_.tf_v1_checkpoint_aggregation_ = tf_v1_checkpoint_aggregation;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.AggregationConfig.tf_v1_checkpoint_aggregation)
}
inline ::google::internal::federated::plan::TFV1CheckpointAggregation* AggregationConfig::_internal_mutable_tf_v1_checkpoint_aggregation() {
  if (!_internal_has_tf_v1_checkpoint_aggregation()) {
    clear_protocol_config();
    set_has_tf_v1_checkpoint_aggregation();
    _impl_.protocol_config_.tf_v1_checkpoint_aggregation_ = CreateMaybeMessage< ::google::internal::federated::plan::TFV1CheckpointAggregation >(GetArenaForAllocation());
  }
  return _impl_.protocol_config_.tf_v1_checkpoint_aggregation_;
}
inline ::google::internal::federated::plan::TFV1CheckpointAggregation* AggregationConfig::mutable_tf_v1_checkpoint_aggregation() {
  ::google::internal::federated::plan::TFV1CheckpointAggregation* _msg = _internal_mutable_tf_v1_checkpoint_aggregation();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.AggregationConfig.tf_v1_checkpoint_aggregation)
  return _msg;
}

inline bool AggregationConfig::has_protocol_config() const {
  return protocol_config_case() != PROTOCOL_CONFIG_NOT_SET;
}
inline void AggregationConfig::clear_has_protocol_config() {
  _impl_._oneof_case_[0] = PROTOCOL_CONFIG_NOT_SET;
}
inline AggregationConfig::ProtocolConfigCase AggregationConfig::protocol_config_case() const {
  return AggregationConfig::ProtocolConfigCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// SecureAggregationConfig

// -------------------------------------------------------------------

// TFV1CheckpointAggregation

// -------------------------------------------------------------------

// FederatedComputeEligibilityIORouter

// string input_filepath_tensor_name = 1;
inline void FederatedComputeEligibilityIORouter::clear_input_filepath_tensor_name() {
  _impl_.input_filepath_tensor_name_.ClearToEmpty();
}
inline const std::string& FederatedComputeEligibilityIORouter::input_filepath_tensor_name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.FederatedComputeEligibilityIORouter.input_filepath_tensor_name)
  return _internal_input_filepath_tensor_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void FederatedComputeEligibilityIORouter::set_input_filepath_tensor_name(ArgT0&& arg0, ArgT... args) {

 _impl_.input_filepath_tensor_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.FederatedComputeEligibilityIORouter.input_filepath_tensor_name)
}
inline std::string* FederatedComputeEligibilityIORouter::mutable_input_filepath_tensor_name() {
  std::string* _s = _internal_mutable_input_filepath_tensor_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.FederatedComputeEligibilityIORouter.input_filepath_tensor_name)
  return _s;
}
inline const std::string& FederatedComputeEligibilityIORouter::_internal_input_filepath_tensor_name() const {
  return _impl_.input_filepath_tensor_name_.Get();
}
inline void FederatedComputeEligibilityIORouter::_internal_set_input_filepath_tensor_name(const std::string& value) {

  _impl_.input_filepath_tensor_name_.Set(value, GetArenaForAllocation());
}
inline std::string* FederatedComputeEligibilityIORouter::_internal_mutable_input_filepath_tensor_name() {

  return _impl_.input_filepath_tensor_name_.Mutable(GetArenaForAllocation());
}
inline std::string* FederatedComputeEligibilityIORouter::release_input_filepath_tensor_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.FederatedComputeEligibilityIORouter.input_filepath_tensor_name)
  return _impl_.input_filepath_tensor_name_.Release();
}
inline void FederatedComputeEligibilityIORouter::set_allocated_input_filepath_tensor_name(std::string* input_filepath_tensor_name) {
  _impl_.input_filepath_tensor_name_.SetAllocated(input_filepath_tensor_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.input_filepath_tensor_name_.IsDefault()) {
    _impl_.input_filepath_tensor_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.FederatedComputeEligibilityIORouter.input_filepath_tensor_name)
}

// string task_eligibility_info_tensor_name = 2;
inline void FederatedComputeEligibilityIORouter::clear_task_eligibility_info_tensor_name() {
  _impl_.task_eligibility_info_tensor_name_.ClearToEmpty();
}
inline const std::string& FederatedComputeEligibilityIORouter::task_eligibility_info_tensor_name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.FederatedComputeEligibilityIORouter.task_eligibility_info_tensor_name)
  return _internal_task_eligibility_info_tensor_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void FederatedComputeEligibilityIORouter::set_task_eligibility_info_tensor_name(ArgT0&& arg0, ArgT... args) {

 _impl_.task_eligibility_info_tensor_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.FederatedComputeEligibilityIORouter.task_eligibility_info_tensor_name)
}
inline std::string* FederatedComputeEligibilityIORouter::mutable_task_eligibility_info_tensor_name() {
  std::string* _s = _internal_mutable_task_eligibility_info_tensor_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.FederatedComputeEligibilityIORouter.task_eligibility_info_tensor_name)
  return _s;
}
inline const std::string& FederatedComputeEligibilityIORouter::_internal_task_eligibility_info_tensor_name() const {
  return _impl_.task_eligibility_info_tensor_name_.Get();
}
inline void FederatedComputeEligibilityIORouter::_internal_set_task_eligibility_info_tensor_name(const std::string& value) {

  _impl_.task_eligibility_info_tensor_name_.Set(value, GetArenaForAllocation());
}
inline std::string* FederatedComputeEligibilityIORouter::_internal_mutable_task_eligibility_info_tensor_name() {

  return _impl_.task_eligibility_info_tensor_name_.Mutable(GetArenaForAllocation());
}
inline std::string* FederatedComputeEligibilityIORouter::release_task_eligibility_info_tensor_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.FederatedComputeEligibilityIORouter.task_eligibility_info_tensor_name)
  return _impl_.task_eligibility_info_tensor_name_.Release();
}
inline void FederatedComputeEligibilityIORouter::set_allocated_task_eligibility_info_tensor_name(std::string* task_eligibility_info_tensor_name) {
  _impl_.task_eligibility_info_tensor_name_.SetAllocated(task_eligibility_info_tensor_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.task_eligibility_info_tensor_name_.IsDefault()) {
    _impl_.task_eligibility_info_tensor_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.FederatedComputeEligibilityIORouter.task_eligibility_info_tensor_name)
}

// -------------------------------------------------------------------

// LocalComputeIORouter

// string input_dir_tensor_name = 1;
inline bool LocalComputeIORouter::_internal_has_input_dir_tensor_name() const {
  return input_resource_case() == kInputDirTensorName;
}
inline bool LocalComputeIORouter::has_input_dir_tensor_name() const {
  return _internal_has_input_dir_tensor_name();
}
inline void LocalComputeIORouter::set_has_input_dir_tensor_name() {
  _impl_._oneof_case_[0] = kInputDirTensorName;
}
inline void LocalComputeIORouter::clear_input_dir_tensor_name() {
  if (_internal_has_input_dir_tensor_name()) {
    _impl_.input_resource_.input_dir_tensor_name_.Destroy();
    clear_has_input_resource();
  }
}
inline const std::string& LocalComputeIORouter::input_dir_tensor_name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.LocalComputeIORouter.input_dir_tensor_name)
  return _internal_input_dir_tensor_name();
}
template <typename ArgT0, typename... ArgT>
inline void LocalComputeIORouter::set_input_dir_tensor_name(ArgT0&& arg0, ArgT... args) {
  if (!_internal_has_input_dir_tensor_name()) {
    clear_input_resource();
    set_has_input_dir_tensor_name();
    _impl_.input_resource_.input_dir_tensor_name_.InitDefault();
  }
  _impl_.input_resource_.input_dir_tensor_name_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.LocalComputeIORouter.input_dir_tensor_name)
}
inline std::string* LocalComputeIORouter::mutable_input_dir_tensor_name() {
  std::string* _s = _internal_mutable_input_dir_tensor_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.LocalComputeIORouter.input_dir_tensor_name)
  return _s;
}
inline const std::string& LocalComputeIORouter::_internal_input_dir_tensor_name() const {
  if (_internal_has_input_dir_tensor_name()) {
    return _impl_.input_resource_.input_dir_tensor_name_.Get();
  }
  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void LocalComputeIORouter::_internal_set_input_dir_tensor_name(const std::string& value) {
  if (!_internal_has_input_dir_tensor_name()) {
    clear_input_resource();
    set_has_input_dir_tensor_name();
    _impl_.input_resource_.input_dir_tensor_name_.InitDefault();
  }
  _impl_.input_resource_.input_dir_tensor_name_.Set(value, GetArenaForAllocation());
}
inline std::string* LocalComputeIORouter::_internal_mutable_input_dir_tensor_name() {
  if (!_internal_has_input_dir_tensor_name()) {
    clear_input_resource();
    set_has_input_dir_tensor_name();
    _impl_.input_resource_.input_dir_tensor_name_.InitDefault();
  }
  return _impl_.input_resource_.input_dir_tensor_name_.Mutable(      GetArenaForAllocation());
}
inline std::string* LocalComputeIORouter::release_input_dir_tensor_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.LocalComputeIORouter.input_dir_tensor_name)
  if (_internal_has_input_dir_tensor_name()) {
    clear_has_input_resource();
    return _impl_.input_resource_.input_dir_tensor_name_.Release();
  } else {
    return nullptr;
  }
}
inline void LocalComputeIORouter::set_allocated_input_dir_tensor_name(std::string* input_dir_tensor_name) {
  if (has_input_resource()) {
    clear_input_resource();
  }
  if (input_dir_tensor_name != nullptr) {
    set_has_input_dir_tensor_name();
    _impl_.input_resource_.input_dir_tensor_name_.InitAllocated(input_dir_tensor_name, GetArenaForAllocation());
  }
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.LocalComputeIORouter.input_dir_tensor_name)
}

// .google.internal.federated.plan.MultipleInputResources multiple_input_resources = 3;
inline bool LocalComputeIORouter::_internal_has_multiple_input_resources() const {
  return input_resource_case() == kMultipleInputResources;
}
inline bool LocalComputeIORouter::has_multiple_input_resources() const {
  return _internal_has_multiple_input_resources();
}
inline void LocalComputeIORouter::set_has_multiple_input_resources() {
  _impl_._oneof_case_[0] = kMultipleInputResources;
}
inline void LocalComputeIORouter::clear_multiple_input_resources() {
  if (_internal_has_multiple_input_resources()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.input_resource_.multiple_input_resources_;
    }
    clear_has_input_resource();
  }
}
inline ::google::internal::federated::plan::MultipleInputResources* LocalComputeIORouter::release_multiple_input_resources() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.LocalComputeIORouter.multiple_input_resources)
  if (_internal_has_multiple_input_resources()) {
    clear_has_input_resource();
    ::google::internal::federated::plan::MultipleInputResources* temp = _impl_.input_resource_.multiple_input_resources_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.input_resource_.multiple_input_resources_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::google::internal::federated::plan::MultipleInputResources& LocalComputeIORouter::_internal_multiple_input_resources() const {
  return _internal_has_multiple_input_resources()
      ? *_impl_.input_resource_.multiple_input_resources_
      : reinterpret_cast< ::google::internal::federated::plan::MultipleInputResources&>(::google::internal::federated::plan::_MultipleInputResources_default_instance_);
}
inline const ::google::internal::federated::plan::MultipleInputResources& LocalComputeIORouter::multiple_input_resources() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.LocalComputeIORouter.multiple_input_resources)
  return _internal_multiple_input_resources();
}
inline ::google::internal::federated::plan::MultipleInputResources* LocalComputeIORouter::unsafe_arena_release_multiple_input_resources() {
  // @@protoc_insertion_point(field_unsafe_arena_release:google.internal.federated.plan.LocalComputeIORouter.multiple_input_resources)
  if (_internal_has_multiple_input_resources()) {
    clear_has_input_resource();
    ::google::internal::federated::plan::MultipleInputResources* temp = _impl_.input_resource_.multiple_input_resources_;
    _impl_.input_resource_.multiple_input_resources_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void LocalComputeIORouter::unsafe_arena_set_allocated_multiple_input_resources(::google::internal::federated::plan::MultipleInputResources* multiple_input_resources) {
  clear_input_resource();
  if (multiple_input_resources) {
    set_has_multiple_input_resources();
    _impl_.input_resource_.multiple_input_resources_ = multiple_input_resources;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.LocalComputeIORouter.multiple_input_resources)
}
inline ::google::internal::federated::plan::MultipleInputResources* LocalComputeIORouter::_internal_mutable_multiple_input_resources() {
  if (!_internal_has_multiple_input_resources()) {
    clear_input_resource();
    set_has_multiple_input_resources();
    _impl_.input_resource_.multiple_input_resources_ = CreateMaybeMessage< ::google::internal::federated::plan::MultipleInputResources >(GetArenaForAllocation());
  }
  return _impl_.input_resource_.multiple_input_resources_;
}
inline ::google::internal::federated::plan::MultipleInputResources* LocalComputeIORouter::mutable_multiple_input_resources() {
  ::google::internal::federated::plan::MultipleInputResources* _msg = _internal_mutable_multiple_input_resources();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.LocalComputeIORouter.multiple_input_resources)
  return _msg;
}

// string output_dir_tensor_name = 2;
inline void LocalComputeIORouter::clear_output_dir_tensor_name() {
  _impl_.output_dir_tensor_name_.ClearToEmpty();
}
inline const std::string& LocalComputeIORouter::output_dir_tensor_name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.LocalComputeIORouter.output_dir_tensor_name)
  return _internal_output_dir_tensor_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LocalComputeIORouter::set_output_dir_tensor_name(ArgT0&& arg0, ArgT... args) {

 _impl_.output_dir_tensor_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.LocalComputeIORouter.output_dir_tensor_name)
}
inline std::string* LocalComputeIORouter::mutable_output_dir_tensor_name() {
  std::string* _s = _internal_mutable_output_dir_tensor_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.LocalComputeIORouter.output_dir_tensor_name)
  return _s;
}
inline const std::string& LocalComputeIORouter::_internal_output_dir_tensor_name() const {
  return _impl_.output_dir_tensor_name_.Get();
}
inline void LocalComputeIORouter::_internal_set_output_dir_tensor_name(const std::string& value) {

  _impl_.output_dir_tensor_name_.Set(value, GetArenaForAllocation());
}
inline std::string* LocalComputeIORouter::_internal_mutable_output_dir_tensor_name() {

  return _impl_.output_dir_tensor_name_.Mutable(GetArenaForAllocation());
}
inline std::string* LocalComputeIORouter::release_output_dir_tensor_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.LocalComputeIORouter.output_dir_tensor_name)
  return _impl_.output_dir_tensor_name_.Release();
}
inline void LocalComputeIORouter::set_allocated_output_dir_tensor_name(std::string* output_dir_tensor_name) {
  _impl_.output_dir_tensor_name_.SetAllocated(output_dir_tensor_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.output_dir_tensor_name_.IsDefault()) {
    _impl_.output_dir_tensor_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.LocalComputeIORouter.output_dir_tensor_name)
}

inline bool LocalComputeIORouter::has_input_resource() const {
  return input_resource_case() != INPUT_RESOURCE_NOT_SET;
}
inline void LocalComputeIORouter::clear_has_input_resource() {
  _impl_._oneof_case_[0] = INPUT_RESOURCE_NOT_SET;
}
inline LocalComputeIORouter::InputResourceCase LocalComputeIORouter::input_resource_case() const {
  return LocalComputeIORouter::InputResourceCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// MultipleInputResources

// map<string, string> input_resource_tensor_name_map = 1;
inline int MultipleInputResources::_internal_input_resource_tensor_name_map_size() const {
  return _impl_.input_resource_tensor_name_map_.size();
}
inline int MultipleInputResources::input_resource_tensor_name_map_size() const {
  return _internal_input_resource_tensor_name_map_size();
}
inline void MultipleInputResources::clear_input_resource_tensor_name_map() {
  _impl_.input_resource_tensor_name_map_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
MultipleInputResources::_internal_input_resource_tensor_name_map() const {
  return _impl_.input_resource_tensor_name_map_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
MultipleInputResources::input_resource_tensor_name_map() const {
  // @@protoc_insertion_point(field_map:google.internal.federated.plan.MultipleInputResources.input_resource_tensor_name_map)
  return _internal_input_resource_tensor_name_map();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
MultipleInputResources::_internal_mutable_input_resource_tensor_name_map() {
  return _impl_.input_resource_tensor_name_map_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
MultipleInputResources::mutable_input_resource_tensor_name_map() {
  // @@protoc_insertion_point(field_mutable_map:google.internal.federated.plan.MultipleInputResources.input_resource_tensor_name_map)
  return _internal_mutable_input_resource_tensor_name_map();
}

// -------------------------------------------------------------------

// AsyncInputFeed

// string enqueue_op = 1;
inline void AsyncInputFeed::clear_enqueue_op() {
  _impl_.enqueue_op_.ClearToEmpty();
}
inline const std::string& AsyncInputFeed::enqueue_op() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.AsyncInputFeed.enqueue_op)
  return _internal_enqueue_op();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AsyncInputFeed::set_enqueue_op(ArgT0&& arg0, ArgT... args) {

 _impl_.enqueue_op_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.AsyncInputFeed.enqueue_op)
}
inline std::string* AsyncInputFeed::mutable_enqueue_op() {
  std::string* _s = _internal_mutable_enqueue_op();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.AsyncInputFeed.enqueue_op)
  return _s;
}
inline const std::string& AsyncInputFeed::_internal_enqueue_op() const {
  return _impl_.enqueue_op_.Get();
}
inline void AsyncInputFeed::_internal_set_enqueue_op(const std::string& value) {

  _impl_.enqueue_op_.Set(value, GetArenaForAllocation());
}
inline std::string* AsyncInputFeed::_internal_mutable_enqueue_op() {

  return _impl_.enqueue_op_.Mutable(GetArenaForAllocation());
}
inline std::string* AsyncInputFeed::release_enqueue_op() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.AsyncInputFeed.enqueue_op)
  return _impl_.enqueue_op_.Release();
}
inline void AsyncInputFeed::set_allocated_enqueue_op(std::string* enqueue_op) {
  _impl_.enqueue_op_.SetAllocated(enqueue_op, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.enqueue_op_.IsDefault()) {
    _impl_.enqueue_op_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.AsyncInputFeed.enqueue_op)
}

// repeated string enqueue_params = 2;
inline int AsyncInputFeed::_internal_enqueue_params_size() const {
  return _impl_.enqueue_params_.size();
}
inline int AsyncInputFeed::enqueue_params_size() const {
  return _internal_enqueue_params_size();
}
inline void AsyncInputFeed::clear_enqueue_params() {
  _impl_.enqueue_params_.Clear();
}
inline std::string* AsyncInputFeed::add_enqueue_params() {
  std::string* _s = _internal_add_enqueue_params();
  // @@protoc_insertion_point(field_add_mutable:google.internal.federated.plan.AsyncInputFeed.enqueue_params)
  return _s;
}
inline const std::string& AsyncInputFeed::_internal_enqueue_params(int index) const {
  return _impl_.enqueue_params_.Get(index);
}
inline const std::string& AsyncInputFeed::enqueue_params(int index) const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.AsyncInputFeed.enqueue_params)
  return _internal_enqueue_params(index);
}
inline std::string* AsyncInputFeed::mutable_enqueue_params(int index) {
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.AsyncInputFeed.enqueue_params)
  return _impl_.enqueue_params_.Mutable(index);
}
inline void AsyncInputFeed::set_enqueue_params(int index, const std::string& value) {
  _impl_.enqueue_params_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.AsyncInputFeed.enqueue_params)
}
inline void AsyncInputFeed::set_enqueue_params(int index, std::string&& value) {
  _impl_.enqueue_params_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.AsyncInputFeed.enqueue_params)
}
inline void AsyncInputFeed::set_enqueue_params(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.enqueue_params_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:google.internal.federated.plan.AsyncInputFeed.enqueue_params)
}
inline void AsyncInputFeed::set_enqueue_params(int index, const char* value, size_t size) {
  _impl_.enqueue_params_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:google.internal.federated.plan.AsyncInputFeed.enqueue_params)
}
inline std::string* AsyncInputFeed::_internal_add_enqueue_params() {
  return _impl_.enqueue_params_.Add();
}
inline void AsyncInputFeed::add_enqueue_params(const std::string& value) {
  _impl_.enqueue_params_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:google.internal.federated.plan.AsyncInputFeed.enqueue_params)
}
inline void AsyncInputFeed::add_enqueue_params(std::string&& value) {
  _impl_.enqueue_params_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:google.internal.federated.plan.AsyncInputFeed.enqueue_params)
}
inline void AsyncInputFeed::add_enqueue_params(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.enqueue_params_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:google.internal.federated.plan.AsyncInputFeed.enqueue_params)
}
inline void AsyncInputFeed::add_enqueue_params(const char* value, size_t size) {
  _impl_.enqueue_params_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:google.internal.federated.plan.AsyncInputFeed.enqueue_params)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
AsyncInputFeed::enqueue_params() const {
  // @@protoc_insertion_point(field_list:google.internal.federated.plan.AsyncInputFeed.enqueue_params)
  return _impl_.enqueue_params_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
AsyncInputFeed::mutable_enqueue_params() {
  // @@protoc_insertion_point(field_mutable_list:google.internal.federated.plan.AsyncInputFeed.enqueue_params)
  return &_impl_.enqueue_params_;
}

// string close_op = 3;
inline void AsyncInputFeed::clear_close_op() {
  _impl_.close_op_.ClearToEmpty();
}
inline const std::string& AsyncInputFeed::close_op() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.AsyncInputFeed.close_op)
  return _internal_close_op();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AsyncInputFeed::set_close_op(ArgT0&& arg0, ArgT... args) {

 _impl_.close_op_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.AsyncInputFeed.close_op)
}
inline std::string* AsyncInputFeed::mutable_close_op() {
  std::string* _s = _internal_mutable_close_op();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.AsyncInputFeed.close_op)
  return _s;
}
inline const std::string& AsyncInputFeed::_internal_close_op() const {
  return _impl_.close_op_.Get();
}
inline void AsyncInputFeed::_internal_set_close_op(const std::string& value) {

  _impl_.close_op_.Set(value, GetArenaForAllocation());
}
inline std::string* AsyncInputFeed::_internal_mutable_close_op() {

  return _impl_.close_op_.Mutable(GetArenaForAllocation());
}
inline std::string* AsyncInputFeed::release_close_op() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.AsyncInputFeed.close_op)
  return _impl_.close_op_.Release();
}
inline void AsyncInputFeed::set_allocated_close_op(std::string* close_op) {
  _impl_.close_op_.SetAllocated(close_op, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.close_op_.IsDefault()) {
    _impl_.close_op_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.AsyncInputFeed.close_op)
}

// bool feed_values_are_data = 4;
inline void AsyncInputFeed::clear_feed_values_are_data() {
  _impl_.feed_values_are_data_ = false;
}
inline bool AsyncInputFeed::_internal_feed_values_are_data() const {
  return _impl_.feed_values_are_data_;
}
inline bool AsyncInputFeed::feed_values_are_data() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.AsyncInputFeed.feed_values_are_data)
  return _internal_feed_values_are_data();
}
inline void AsyncInputFeed::_internal_set_feed_values_are_data(bool value) {

  _impl_.feed_values_are_data_ = value;
}
inline void AsyncInputFeed::set_feed_values_are_data(bool value) {
  _internal_set_feed_values_are_data(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.AsyncInputFeed.feed_values_are_data)
}

// -------------------------------------------------------------------

// DatasetInput

// string initializer = 1;
inline void DatasetInput::clear_initializer() {
  _impl_.initializer_.ClearToEmpty();
}
inline const std::string& DatasetInput::initializer() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.DatasetInput.initializer)
  return _internal_initializer();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DatasetInput::set_initializer(ArgT0&& arg0, ArgT... args) {

 _impl_.initializer_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.DatasetInput.initializer)
}
inline std::string* DatasetInput::mutable_initializer() {
  std::string* _s = _internal_mutable_initializer();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.DatasetInput.initializer)
  return _s;
}
inline const std::string& DatasetInput::_internal_initializer() const {
  return _impl_.initializer_.Get();
}
inline void DatasetInput::_internal_set_initializer(const std::string& value) {

  _impl_.initializer_.Set(value, GetArenaForAllocation());
}
inline std::string* DatasetInput::_internal_mutable_initializer() {

  return _impl_.initializer_.Mutable(GetArenaForAllocation());
}
inline std::string* DatasetInput::release_initializer() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.DatasetInput.initializer)
  return _impl_.initializer_.Release();
}
inline void DatasetInput::set_allocated_initializer(std::string* initializer) {
  _impl_.initializer_.SetAllocated(initializer, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.initializer_.IsDefault()) {
    _impl_.initializer_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.DatasetInput.initializer)
}

// .google.internal.federated.plan.DatasetInputPlaceholders placeholders = 2;
inline bool DatasetInput::_internal_has_placeholders() const {
  return this != internal_default_instance() && _impl_.placeholders_ != nullptr;
}
inline bool DatasetInput::has_placeholders() const {
  return _internal_has_placeholders();
}
inline void DatasetInput::clear_placeholders() {
  if (GetArenaForAllocation() == nullptr && _impl_.placeholders_ != nullptr) {
    delete _impl_.placeholders_;
  }
  _impl_.placeholders_ = nullptr;
}
inline const ::google::internal::federated::plan::DatasetInputPlaceholders& DatasetInput::_internal_placeholders() const {
  const ::google::internal::federated::plan::DatasetInputPlaceholders* p = _impl_.placeholders_;
  return p != nullptr ? *p : reinterpret_cast<const ::google::internal::federated::plan::DatasetInputPlaceholders&>(
      ::google::internal::federated::plan::_DatasetInputPlaceholders_default_instance_);
}
inline const ::google::internal::federated::plan::DatasetInputPlaceholders& DatasetInput::placeholders() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.DatasetInput.placeholders)
  return _internal_placeholders();
}
inline void DatasetInput::unsafe_arena_set_allocated_placeholders(
    ::google::internal::federated::plan::DatasetInputPlaceholders* placeholders) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.placeholders_);
  }
  _impl_.placeholders_ = placeholders;
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.DatasetInput.placeholders)
}
inline ::google::internal::federated::plan::DatasetInputPlaceholders* DatasetInput::release_placeholders() {

  ::google::internal::federated::plan::DatasetInputPlaceholders* temp = _impl_.placeholders_;
  _impl_.placeholders_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::google::internal::federated::plan::DatasetInputPlaceholders* DatasetInput::unsafe_arena_release_placeholders() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.DatasetInput.placeholders)

  ::google::internal::federated::plan::DatasetInputPlaceholders* temp = _impl_.placeholders_;
  _impl_.placeholders_ = nullptr;
  return temp;
}
inline ::google::internal::federated::plan::DatasetInputPlaceholders* DatasetInput::_internal_mutable_placeholders() {

  if (_impl_.placeholders_ == nullptr) {
    auto* p = CreateMaybeMessage<::google::internal::federated::plan::DatasetInputPlaceholders>(GetArenaForAllocation());
    _impl_.placeholders_ = p;
  }
  return _impl_.placeholders_;
}
inline ::google::internal::federated::plan::DatasetInputPlaceholders* DatasetInput::mutable_placeholders() {
  ::google::internal::federated::plan::DatasetInputPlaceholders* _msg = _internal_mutable_placeholders();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.DatasetInput.placeholders)
  return _msg;
}
inline void DatasetInput::set_allocated_placeholders(::google::internal::federated::plan::DatasetInputPlaceholders* placeholders) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.placeholders_;
  }
  if (placeholders) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(placeholders);
    if (message_arena != submessage_arena) {
      placeholders = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, placeholders, submessage_arena);
    }

  } else {

  }
  _impl_.placeholders_ = placeholders;
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.DatasetInput.placeholders)
}

// int32 batch_size = 3;
inline void DatasetInput::clear_batch_size() {
  _impl_.batch_size_ = 0;
}
inline ::int32_t DatasetInput::_internal_batch_size() const {
  return _impl_.batch_size_;
}
inline ::int32_t DatasetInput::batch_size() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.DatasetInput.batch_size)
  return _internal_batch_size();
}
inline void DatasetInput::_internal_set_batch_size(::int32_t value) {

  _impl_.batch_size_ = value;
}
inline void DatasetInput::set_batch_size(::int32_t value) {
  _internal_set_batch_size(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.DatasetInput.batch_size)
}

// -------------------------------------------------------------------

// DatasetInputPlaceholders

// string filename = 1;
inline void DatasetInputPlaceholders::clear_filename() {
  _impl_.filename_.ClearToEmpty();
}
inline const std::string& DatasetInputPlaceholders::filename() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.DatasetInputPlaceholders.filename)
  return _internal_filename();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DatasetInputPlaceholders::set_filename(ArgT0&& arg0, ArgT... args) {

 _impl_.filename_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.DatasetInputPlaceholders.filename)
}
inline std::string* DatasetInputPlaceholders::mutable_filename() {
  std::string* _s = _internal_mutable_filename();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.DatasetInputPlaceholders.filename)
  return _s;
}
inline const std::string& DatasetInputPlaceholders::_internal_filename() const {
  return _impl_.filename_.Get();
}
inline void DatasetInputPlaceholders::_internal_set_filename(const std::string& value) {

  _impl_.filename_.Set(value, GetArenaForAllocation());
}
inline std::string* DatasetInputPlaceholders::_internal_mutable_filename() {

  return _impl_.filename_.Mutable(GetArenaForAllocation());
}
inline std::string* DatasetInputPlaceholders::release_filename() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.DatasetInputPlaceholders.filename)
  return _impl_.filename_.Release();
}
inline void DatasetInputPlaceholders::set_allocated_filename(std::string* filename) {
  _impl_.filename_.SetAllocated(filename, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.filename_.IsDefault()) {
    _impl_.filename_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.DatasetInputPlaceholders.filename)
}

// string key_prefix = 2;
inline void DatasetInputPlaceholders::clear_key_prefix() {
  _impl_.key_prefix_.ClearToEmpty();
}
inline const std::string& DatasetInputPlaceholders::key_prefix() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.DatasetInputPlaceholders.key_prefix)
  return _internal_key_prefix();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DatasetInputPlaceholders::set_key_prefix(ArgT0&& arg0, ArgT... args) {

 _impl_.key_prefix_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.DatasetInputPlaceholders.key_prefix)
}
inline std::string* DatasetInputPlaceholders::mutable_key_prefix() {
  std::string* _s = _internal_mutable_key_prefix();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.DatasetInputPlaceholders.key_prefix)
  return _s;
}
inline const std::string& DatasetInputPlaceholders::_internal_key_prefix() const {
  return _impl_.key_prefix_.Get();
}
inline void DatasetInputPlaceholders::_internal_set_key_prefix(const std::string& value) {

  _impl_.key_prefix_.Set(value, GetArenaForAllocation());
}
inline std::string* DatasetInputPlaceholders::_internal_mutable_key_prefix() {

  return _impl_.key_prefix_.Mutable(GetArenaForAllocation());
}
inline std::string* DatasetInputPlaceholders::release_key_prefix() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.DatasetInputPlaceholders.key_prefix)
  return _impl_.key_prefix_.Release();
}
inline void DatasetInputPlaceholders::set_allocated_key_prefix(std::string* key_prefix) {
  _impl_.key_prefix_.SetAllocated(key_prefix, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.key_prefix_.IsDefault()) {
    _impl_.key_prefix_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.DatasetInputPlaceholders.key_prefix)
}

// string num_epochs = 3;
inline void DatasetInputPlaceholders::clear_num_epochs() {
  _impl_.num_epochs_.ClearToEmpty();
}
inline const std::string& DatasetInputPlaceholders::num_epochs() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.DatasetInputPlaceholders.num_epochs)
  return _internal_num_epochs();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DatasetInputPlaceholders::set_num_epochs(ArgT0&& arg0, ArgT... args) {

 _impl_.num_epochs_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.DatasetInputPlaceholders.num_epochs)
}
inline std::string* DatasetInputPlaceholders::mutable_num_epochs() {
  std::string* _s = _internal_mutable_num_epochs();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.DatasetInputPlaceholders.num_epochs)
  return _s;
}
inline const std::string& DatasetInputPlaceholders::_internal_num_epochs() const {
  return _impl_.num_epochs_.Get();
}
inline void DatasetInputPlaceholders::_internal_set_num_epochs(const std::string& value) {

  _impl_.num_epochs_.Set(value, GetArenaForAllocation());
}
inline std::string* DatasetInputPlaceholders::_internal_mutable_num_epochs() {

  return _impl_.num_epochs_.Mutable(GetArenaForAllocation());
}
inline std::string* DatasetInputPlaceholders::release_num_epochs() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.DatasetInputPlaceholders.num_epochs)
  return _impl_.num_epochs_.Release();
}
inline void DatasetInputPlaceholders::set_allocated_num_epochs(std::string* num_epochs) {
  _impl_.num_epochs_.SetAllocated(num_epochs, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.num_epochs_.IsDefault()) {
    _impl_.num_epochs_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.DatasetInputPlaceholders.num_epochs)
}

// string batch_size = 4;
inline void DatasetInputPlaceholders::clear_batch_size() {
  _impl_.batch_size_.ClearToEmpty();
}
inline const std::string& DatasetInputPlaceholders::batch_size() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.DatasetInputPlaceholders.batch_size)
  return _internal_batch_size();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DatasetInputPlaceholders::set_batch_size(ArgT0&& arg0, ArgT... args) {

 _impl_.batch_size_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.DatasetInputPlaceholders.batch_size)
}
inline std::string* DatasetInputPlaceholders::mutable_batch_size() {
  std::string* _s = _internal_mutable_batch_size();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.DatasetInputPlaceholders.batch_size)
  return _s;
}
inline const std::string& DatasetInputPlaceholders::_internal_batch_size() const {
  return _impl_.batch_size_.Get();
}
inline void DatasetInputPlaceholders::_internal_set_batch_size(const std::string& value) {

  _impl_.batch_size_.Set(value, GetArenaForAllocation());
}
inline std::string* DatasetInputPlaceholders::_internal_mutable_batch_size() {

  return _impl_.batch_size_.Mutable(GetArenaForAllocation());
}
inline std::string* DatasetInputPlaceholders::release_batch_size() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.DatasetInputPlaceholders.batch_size)
  return _impl_.batch_size_.Release();
}
inline void DatasetInputPlaceholders::set_allocated_batch_size(std::string* batch_size) {
  _impl_.batch_size_.SetAllocated(batch_size, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.batch_size_.IsDefault()) {
    _impl_.batch_size_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.DatasetInputPlaceholders.batch_size)
}

// -------------------------------------------------------------------

// ExampleSelector

// .google.protobuf.Any criteria = 1;
inline bool ExampleSelector::_internal_has_criteria() const {
  return this != internal_default_instance() && _impl_.criteria_ != nullptr;
}
inline bool ExampleSelector::has_criteria() const {
  return _internal_has_criteria();
}
inline const ::PROTOBUF_NAMESPACE_ID::Any& ExampleSelector::_internal_criteria() const {
  const ::PROTOBUF_NAMESPACE_ID::Any* p = _impl_.criteria_;
  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Any&>(
      ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::Any& ExampleSelector::criteria() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ExampleSelector.criteria)
  return _internal_criteria();
}
inline void ExampleSelector::unsafe_arena_set_allocated_criteria(
    ::PROTOBUF_NAMESPACE_ID::Any* criteria) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.criteria_);
  }
  _impl_.criteria_ = criteria;
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.ExampleSelector.criteria)
}
inline ::PROTOBUF_NAMESPACE_ID::Any* ExampleSelector::release_criteria() {

  ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.criteria_;
  _impl_.criteria_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* ExampleSelector::unsafe_arena_release_criteria() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ExampleSelector.criteria)

  ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.criteria_;
  _impl_.criteria_ = nullptr;
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* ExampleSelector::_internal_mutable_criteria() {

  if (_impl_.criteria_ == nullptr) {
    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation());
    _impl_.criteria_ = p;
  }
  return _impl_.criteria_;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* ExampleSelector::mutable_criteria() {
  ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_criteria();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ExampleSelector.criteria)
  return _msg;
}
inline void ExampleSelector::set_allocated_criteria(::PROTOBUF_NAMESPACE_ID::Any* criteria) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.criteria_);
  }
  if (criteria) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(criteria));
    if (message_arena != submessage_arena) {
      criteria = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, criteria, submessage_arena);
    }

  } else {

  }
  _impl_.criteria_ = criteria;
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ExampleSelector.criteria)
}

// string collection_uri = 2;
inline void ExampleSelector::clear_collection_uri() {
  _impl_.collection_uri_.ClearToEmpty();
}
inline const std::string& ExampleSelector::collection_uri() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ExampleSelector.collection_uri)
  return _internal_collection_uri();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ExampleSelector::set_collection_uri(ArgT0&& arg0, ArgT... args) {

 _impl_.collection_uri_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.ExampleSelector.collection_uri)
}
inline std::string* ExampleSelector::mutable_collection_uri() {
  std::string* _s = _internal_mutable_collection_uri();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ExampleSelector.collection_uri)
  return _s;
}
inline const std::string& ExampleSelector::_internal_collection_uri() const {
  return _impl_.collection_uri_.Get();
}
inline void ExampleSelector::_internal_set_collection_uri(const std::string& value) {

  _impl_.collection_uri_.Set(value, GetArenaForAllocation());
}
inline std::string* ExampleSelector::_internal_mutable_collection_uri() {

  return _impl_.collection_uri_.Mutable(GetArenaForAllocation());
}
inline std::string* ExampleSelector::release_collection_uri() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ExampleSelector.collection_uri)
  return _impl_.collection_uri_.Release();
}
inline void ExampleSelector::set_allocated_collection_uri(std::string* collection_uri) {
  _impl_.collection_uri_.SetAllocated(collection_uri, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.collection_uri_.IsDefault()) {
    _impl_.collection_uri_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ExampleSelector.collection_uri)
}

// .google.protobuf.Any resumption_token = 3;
inline bool ExampleSelector::_internal_has_resumption_token() const {
  return this != internal_default_instance() && _impl_.resumption_token_ != nullptr;
}
inline bool ExampleSelector::has_resumption_token() const {
  return _internal_has_resumption_token();
}
inline const ::PROTOBUF_NAMESPACE_ID::Any& ExampleSelector::_internal_resumption_token() const {
  const ::PROTOBUF_NAMESPACE_ID::Any* p = _impl_.resumption_token_;
  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Any&>(
      ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::Any& ExampleSelector::resumption_token() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ExampleSelector.resumption_token)
  return _internal_resumption_token();
}
inline void ExampleSelector::unsafe_arena_set_allocated_resumption_token(
    ::PROTOBUF_NAMESPACE_ID::Any* resumption_token) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.resumption_token_);
  }
  _impl_.resumption_token_ = resumption_token;
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.ExampleSelector.resumption_token)
}
inline ::PROTOBUF_NAMESPACE_ID::Any* ExampleSelector::release_resumption_token() {

  ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.resumption_token_;
  _impl_.resumption_token_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* ExampleSelector::unsafe_arena_release_resumption_token() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ExampleSelector.resumption_token)

  ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.resumption_token_;
  _impl_.resumption_token_ = nullptr;
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* ExampleSelector::_internal_mutable_resumption_token() {

  if (_impl_.resumption_token_ == nullptr) {
    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation());
    _impl_.resumption_token_ = p;
  }
  return _impl_.resumption_token_;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* ExampleSelector::mutable_resumption_token() {
  ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_resumption_token();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ExampleSelector.resumption_token)
  return _msg;
}
inline void ExampleSelector::set_allocated_resumption_token(::PROTOBUF_NAMESPACE_ID::Any* resumption_token) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.resumption_token_);
  }
  if (resumption_token) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(resumption_token));
    if (message_arena != submessage_arena) {
      resumption_token = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, resumption_token, submessage_arena);
    }

  } else {

  }
  _impl_.resumption_token_ = resumption_token;
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ExampleSelector.resumption_token)
}

// -------------------------------------------------------------------

// SlicesSelector

// string served_at_id = 1;
inline void SlicesSelector::clear_served_at_id() {
  _impl_.served_at_id_.ClearToEmpty();
}
inline const std::string& SlicesSelector::served_at_id() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.SlicesSelector.served_at_id)
  return _internal_served_at_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SlicesSelector::set_served_at_id(ArgT0&& arg0, ArgT... args) {

 _impl_.served_at_id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.SlicesSelector.served_at_id)
}
inline std::string* SlicesSelector::mutable_served_at_id() {
  std::string* _s = _internal_mutable_served_at_id();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.SlicesSelector.served_at_id)
  return _s;
}
inline const std::string& SlicesSelector::_internal_served_at_id() const {
  return _impl_.served_at_id_.Get();
}
inline void SlicesSelector::_internal_set_served_at_id(const std::string& value) {

  _impl_.served_at_id_.Set(value, GetArenaForAllocation());
}
inline std::string* SlicesSelector::_internal_mutable_served_at_id() {

  return _impl_.served_at_id_.Mutable(GetArenaForAllocation());
}
inline std::string* SlicesSelector::release_served_at_id() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.SlicesSelector.served_at_id)
  return _impl_.served_at_id_.Release();
}
inline void SlicesSelector::set_allocated_served_at_id(std::string* served_at_id) {
  _impl_.served_at_id_.SetAllocated(served_at_id, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.served_at_id_.IsDefault()) {
    _impl_.served_at_id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.SlicesSelector.served_at_id)
}

// repeated int32 keys = 2;
inline int SlicesSelector::_internal_keys_size() const {
  return _impl_.keys_.size();
}
inline int SlicesSelector::keys_size() const {
  return _internal_keys_size();
}
inline void SlicesSelector::clear_keys() {
  _impl_.keys_.Clear();
}
inline ::int32_t SlicesSelector::_internal_keys(int index) const {
  return _impl_.keys_.Get(index);
}
inline ::int32_t SlicesSelector::keys(int index) const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.SlicesSelector.keys)
  return _internal_keys(index);
}
inline void SlicesSelector::set_keys(int index, ::int32_t value) {
  _impl_.keys_.Set(index, value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.SlicesSelector.keys)
}
inline void SlicesSelector::_internal_add_keys(::int32_t value) {
  _impl_.keys_.Add(value);
}
inline void SlicesSelector::add_keys(::int32_t value) {
  _internal_add_keys(value);
  // @@protoc_insertion_point(field_add:google.internal.federated.plan.SlicesSelector.keys)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int32_t >&
SlicesSelector::_internal_keys() const {
  return _impl_.keys_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int32_t >&
SlicesSelector::keys() const {
  // @@protoc_insertion_point(field_list:google.internal.federated.plan.SlicesSelector.keys)
  return _internal_keys();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int32_t >*
SlicesSelector::_internal_mutable_keys() {
  return &_impl_.keys_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int32_t >*
SlicesSelector::mutable_keys() {
  // @@protoc_insertion_point(field_mutable_list:google.internal.federated.plan.SlicesSelector.keys)
  return _internal_mutable_keys();
}

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// SlicesTestDataset

// map<string, .google.internal.federated.plan.SlicesTestData> dataset = 1;
inline int SlicesTestDataset::_internal_dataset_size() const {
  return _impl_.dataset_.size();
}
inline int SlicesTestDataset::dataset_size() const {
  return _internal_dataset_size();
}
inline void SlicesTestDataset::clear_dataset() {
  _impl_.dataset_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::SlicesTestData >&
SlicesTestDataset::_internal_dataset() const {
  return _impl_.dataset_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::SlicesTestData >&
SlicesTestDataset::dataset() const {
  // @@protoc_insertion_point(field_map:google.internal.federated.plan.SlicesTestDataset.dataset)
  return _internal_dataset();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::SlicesTestData >*
SlicesTestDataset::_internal_mutable_dataset() {
  return _impl_.dataset_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::google::internal::federated::plan::SlicesTestData >*
SlicesTestDataset::mutable_dataset() {
  // @@protoc_insertion_point(field_mutable_map:google.internal.federated.plan.SlicesTestDataset.dataset)
  return _internal_mutable_dataset();
}

// -------------------------------------------------------------------

// SlicesTestData

// repeated bytes slice_data = 2;
inline int SlicesTestData::_internal_slice_data_size() const {
  return _impl_.slice_data_.size();
}
inline int SlicesTestData::slice_data_size() const {
  return _internal_slice_data_size();
}
inline void SlicesTestData::clear_slice_data() {
  _impl_.slice_data_.Clear();
}
inline std::string* SlicesTestData::add_slice_data() {
  std::string* _s = _internal_add_slice_data();
  // @@protoc_insertion_point(field_add_mutable:google.internal.federated.plan.SlicesTestData.slice_data)
  return _s;
}
inline const std::string& SlicesTestData::_internal_slice_data(int index) const {
  return _impl_.slice_data_.Get(index);
}
inline const std::string& SlicesTestData::slice_data(int index) const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.SlicesTestData.slice_data)
  return _internal_slice_data(index);
}
inline std::string* SlicesTestData::mutable_slice_data(int index) {
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.SlicesTestData.slice_data)
  return _impl_.slice_data_.Mutable(index);
}
inline void SlicesTestData::set_slice_data(int index, const std::string& value) {
  _impl_.slice_data_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.SlicesTestData.slice_data)
}
inline void SlicesTestData::set_slice_data(int index, std::string&& value) {
  _impl_.slice_data_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.SlicesTestData.slice_data)
}
inline void SlicesTestData::set_slice_data(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.slice_data_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:google.internal.federated.plan.SlicesTestData.slice_data)
}
inline void SlicesTestData::set_slice_data(int index, const void* value, size_t size) {
  _impl_.slice_data_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:google.internal.federated.plan.SlicesTestData.slice_data)
}
inline std::string* SlicesTestData::_internal_add_slice_data() {
  return _impl_.slice_data_.Add();
}
inline void SlicesTestData::add_slice_data(const std::string& value) {
  _impl_.slice_data_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:google.internal.federated.plan.SlicesTestData.slice_data)
}
inline void SlicesTestData::add_slice_data(std::string&& value) {
  _impl_.slice_data_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:google.internal.federated.plan.SlicesTestData.slice_data)
}
inline void SlicesTestData::add_slice_data(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.slice_data_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:google.internal.federated.plan.SlicesTestData.slice_data)
}
inline void SlicesTestData::add_slice_data(const void* value, size_t size) {
  _impl_.slice_data_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:google.internal.federated.plan.SlicesTestData.slice_data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
SlicesTestData::slice_data() const {
  // @@protoc_insertion_point(field_list:google.internal.federated.plan.SlicesTestData.slice_data)
  return _impl_.slice_data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
SlicesTestData::mutable_slice_data() {
  // @@protoc_insertion_point(field_mutable_list:google.internal.federated.plan.SlicesTestData.slice_data)
  return &_impl_.slice_data_;
}

// -------------------------------------------------------------------

// ServerPhaseV2

// string name = 1;
inline void ServerPhaseV2::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& ServerPhaseV2::name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerPhaseV2.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ServerPhaseV2::set_name(ArgT0&& arg0, ArgT... args) {

 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.ServerPhaseV2.name)
}
inline std::string* ServerPhaseV2::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerPhaseV2.name)
  return _s;
}
inline const std::string& ServerPhaseV2::_internal_name() const {
  return _impl_.name_.Get();
}
inline void ServerPhaseV2::_internal_set_name(const std::string& value) {

  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* ServerPhaseV2::_internal_mutable_name() {

  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* ServerPhaseV2::release_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ServerPhaseV2.name)
  return _impl_.name_.Release();
}
inline void ServerPhaseV2::set_allocated_name(std::string* name) {
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ServerPhaseV2.name)
}

// .google.internal.federated.plan.TensorflowSpec tensorflow_spec_prepare = 3;
inline bool ServerPhaseV2::_internal_has_tensorflow_spec_prepare() const {
  return this != internal_default_instance() && _impl_.tensorflow_spec_prepare_ != nullptr;
}
inline bool ServerPhaseV2::has_tensorflow_spec_prepare() const {
  return _internal_has_tensorflow_spec_prepare();
}
inline void ServerPhaseV2::clear_tensorflow_spec_prepare() {
  if (GetArenaForAllocation() == nullptr && _impl_.tensorflow_spec_prepare_ != nullptr) {
    delete _impl_.tensorflow_spec_prepare_;
  }
  _impl_.tensorflow_spec_prepare_ = nullptr;
}
inline const ::google::internal::federated::plan::TensorflowSpec& ServerPhaseV2::_internal_tensorflow_spec_prepare() const {
  const ::google::internal::federated::plan::TensorflowSpec* p = _impl_.tensorflow_spec_prepare_;
  return p != nullptr ? *p : reinterpret_cast<const ::google::internal::federated::plan::TensorflowSpec&>(
      ::google::internal::federated::plan::_TensorflowSpec_default_instance_);
}
inline const ::google::internal::federated::plan::TensorflowSpec& ServerPhaseV2::tensorflow_spec_prepare() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerPhaseV2.tensorflow_spec_prepare)
  return _internal_tensorflow_spec_prepare();
}
inline void ServerPhaseV2::unsafe_arena_set_allocated_tensorflow_spec_prepare(
    ::google::internal::federated::plan::TensorflowSpec* tensorflow_spec_prepare) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.tensorflow_spec_prepare_);
  }
  _impl_.tensorflow_spec_prepare_ = tensorflow_spec_prepare;
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.ServerPhaseV2.tensorflow_spec_prepare)
}
inline ::google::internal::federated::plan::TensorflowSpec* ServerPhaseV2::release_tensorflow_spec_prepare() {

  ::google::internal::federated::plan::TensorflowSpec* temp = _impl_.tensorflow_spec_prepare_;
  _impl_.tensorflow_spec_prepare_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::google::internal::federated::plan::TensorflowSpec* ServerPhaseV2::unsafe_arena_release_tensorflow_spec_prepare() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ServerPhaseV2.tensorflow_spec_prepare)

  ::google::internal::federated::plan::TensorflowSpec* temp = _impl_.tensorflow_spec_prepare_;
  _impl_.tensorflow_spec_prepare_ = nullptr;
  return temp;
}
inline ::google::internal::federated::plan::TensorflowSpec* ServerPhaseV2::_internal_mutable_tensorflow_spec_prepare() {

  if (_impl_.tensorflow_spec_prepare_ == nullptr) {
    auto* p = CreateMaybeMessage<::google::internal::federated::plan::TensorflowSpec>(GetArenaForAllocation());
    _impl_.tensorflow_spec_prepare_ = p;
  }
  return _impl_.tensorflow_spec_prepare_;
}
inline ::google::internal::federated::plan::TensorflowSpec* ServerPhaseV2::mutable_tensorflow_spec_prepare() {
  ::google::internal::federated::plan::TensorflowSpec* _msg = _internal_mutable_tensorflow_spec_prepare();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerPhaseV2.tensorflow_spec_prepare)
  return _msg;
}
inline void ServerPhaseV2::set_allocated_tensorflow_spec_prepare(::google::internal::federated::plan::TensorflowSpec* tensorflow_spec_prepare) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.tensorflow_spec_prepare_;
  }
  if (tensorflow_spec_prepare) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(tensorflow_spec_prepare);
    if (message_arena != submessage_arena) {
      tensorflow_spec_prepare = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, tensorflow_spec_prepare, submessage_arena);
    }

  } else {

  }
  _impl_.tensorflow_spec_prepare_ = tensorflow_spec_prepare;
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ServerPhaseV2.tensorflow_spec_prepare)
}

// .google.internal.federated.plan.ServerPrepareIORouter prepare_router = 4;
inline bool ServerPhaseV2::_internal_has_prepare_router() const {
  return server_prepare_io_router_case() == kPrepareRouter;
}
inline bool ServerPhaseV2::has_prepare_router() const {
  return _internal_has_prepare_router();
}
inline void ServerPhaseV2::set_has_prepare_router() {
  _impl_._oneof_case_[0] = kPrepareRouter;
}
inline void ServerPhaseV2::clear_prepare_router() {
  if (_internal_has_prepare_router()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.server_prepare_io_router_.prepare_router_;
    }
    clear_has_server_prepare_io_router();
  }
}
inline ::google::internal::federated::plan::ServerPrepareIORouter* ServerPhaseV2::release_prepare_router() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ServerPhaseV2.prepare_router)
  if (_internal_has_prepare_router()) {
    clear_has_server_prepare_io_router();
    ::google::internal::federated::plan::ServerPrepareIORouter* temp = _impl_.server_prepare_io_router_.prepare_router_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.server_prepare_io_router_.prepare_router_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::google::internal::federated::plan::ServerPrepareIORouter& ServerPhaseV2::_internal_prepare_router() const {
  return _internal_has_prepare_router()
      ? *_impl_.server_prepare_io_router_.prepare_router_
      : reinterpret_cast< ::google::internal::federated::plan::ServerPrepareIORouter&>(::google::internal::federated::plan::_ServerPrepareIORouter_default_instance_);
}
inline const ::google::internal::federated::plan::ServerPrepareIORouter& ServerPhaseV2::prepare_router() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerPhaseV2.prepare_router)
  return _internal_prepare_router();
}
inline ::google::internal::federated::plan::ServerPrepareIORouter* ServerPhaseV2::unsafe_arena_release_prepare_router() {
  // @@protoc_insertion_point(field_unsafe_arena_release:google.internal.federated.plan.ServerPhaseV2.prepare_router)
  if (_internal_has_prepare_router()) {
    clear_has_server_prepare_io_router();
    ::google::internal::federated::plan::ServerPrepareIORouter* temp = _impl_.server_prepare_io_router_.prepare_router_;
    _impl_.server_prepare_io_router_.prepare_router_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ServerPhaseV2::unsafe_arena_set_allocated_prepare_router(::google::internal::federated::plan::ServerPrepareIORouter* prepare_router) {
  clear_server_prepare_io_router();
  if (prepare_router) {
    set_has_prepare_router();
    _impl_.server_prepare_io_router_.prepare_router_ = prepare_router;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.ServerPhaseV2.prepare_router)
}
inline ::google::internal::federated::plan::ServerPrepareIORouter* ServerPhaseV2::_internal_mutable_prepare_router() {
  if (!_internal_has_prepare_router()) {
    clear_server_prepare_io_router();
    set_has_prepare_router();
    _impl_.server_prepare_io_router_.prepare_router_ = CreateMaybeMessage< ::google::internal::federated::plan::ServerPrepareIORouter >(GetArenaForAllocation());
  }
  return _impl_.server_prepare_io_router_.prepare_router_;
}
inline ::google::internal::federated::plan::ServerPrepareIORouter* ServerPhaseV2::mutable_prepare_router() {
  ::google::internal::federated::plan::ServerPrepareIORouter* _msg = _internal_mutable_prepare_router();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerPhaseV2.prepare_router)
  return _msg;
}

// repeated .google.internal.federated.plan.ServerAggregationConfig aggregations = 2;
inline int ServerPhaseV2::_internal_aggregations_size() const {
  return _impl_.aggregations_.size();
}
inline int ServerPhaseV2::aggregations_size() const {
  return _internal_aggregations_size();
}
inline void ServerPhaseV2::clear_aggregations() {
  _impl_.aggregations_.Clear();
}
inline ::google::internal::federated::plan::ServerAggregationConfig* ServerPhaseV2::mutable_aggregations(int index) {
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerPhaseV2.aggregations)
  return _impl_.aggregations_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::ServerAggregationConfig >*
ServerPhaseV2::mutable_aggregations() {
  // @@protoc_insertion_point(field_mutable_list:google.internal.federated.plan.ServerPhaseV2.aggregations)
  return &_impl_.aggregations_;
}
inline const ::google::internal::federated::plan::ServerAggregationConfig& ServerPhaseV2::_internal_aggregations(int index) const {
  return _impl_.aggregations_.Get(index);
}
inline const ::google::internal::federated::plan::ServerAggregationConfig& ServerPhaseV2::aggregations(int index) const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerPhaseV2.aggregations)
  return _internal_aggregations(index);
}
inline ::google::internal::federated::plan::ServerAggregationConfig* ServerPhaseV2::_internal_add_aggregations() {
  return _impl_.aggregations_.Add();
}
inline ::google::internal::federated::plan::ServerAggregationConfig* ServerPhaseV2::add_aggregations() {
  ::google::internal::federated::plan::ServerAggregationConfig* _add = _internal_add_aggregations();
  // @@protoc_insertion_point(field_add:google.internal.federated.plan.ServerPhaseV2.aggregations)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::ServerAggregationConfig >&
ServerPhaseV2::aggregations() const {
  // @@protoc_insertion_point(field_list:google.internal.federated.plan.ServerPhaseV2.aggregations)
  return _impl_.aggregations_;
}

// .google.internal.federated.plan.TensorflowSpec tensorflow_spec_result = 5;
inline bool ServerPhaseV2::_internal_has_tensorflow_spec_result() const {
  return this != internal_default_instance() && _impl_.tensorflow_spec_result_ != nullptr;
}
inline bool ServerPhaseV2::has_tensorflow_spec_result() const {
  return _internal_has_tensorflow_spec_result();
}
inline void ServerPhaseV2::clear_tensorflow_spec_result() {
  if (GetArenaForAllocation() == nullptr && _impl_.tensorflow_spec_result_ != nullptr) {
    delete _impl_.tensorflow_spec_result_;
  }
  _impl_.tensorflow_spec_result_ = nullptr;
}
inline const ::google::internal::federated::plan::TensorflowSpec& ServerPhaseV2::_internal_tensorflow_spec_result() const {
  const ::google::internal::federated::plan::TensorflowSpec* p = _impl_.tensorflow_spec_result_;
  return p != nullptr ? *p : reinterpret_cast<const ::google::internal::federated::plan::TensorflowSpec&>(
      ::google::internal::federated::plan::_TensorflowSpec_default_instance_);
}
inline const ::google::internal::federated::plan::TensorflowSpec& ServerPhaseV2::tensorflow_spec_result() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerPhaseV2.tensorflow_spec_result)
  return _internal_tensorflow_spec_result();
}
inline void ServerPhaseV2::unsafe_arena_set_allocated_tensorflow_spec_result(
    ::google::internal::federated::plan::TensorflowSpec* tensorflow_spec_result) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.tensorflow_spec_result_);
  }
  _impl_.tensorflow_spec_result_ = tensorflow_spec_result;
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.ServerPhaseV2.tensorflow_spec_result)
}
inline ::google::internal::federated::plan::TensorflowSpec* ServerPhaseV2::release_tensorflow_spec_result() {

  ::google::internal::federated::plan::TensorflowSpec* temp = _impl_.tensorflow_spec_result_;
  _impl_.tensorflow_spec_result_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::google::internal::federated::plan::TensorflowSpec* ServerPhaseV2::unsafe_arena_release_tensorflow_spec_result() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ServerPhaseV2.tensorflow_spec_result)

  ::google::internal::federated::plan::TensorflowSpec* temp = _impl_.tensorflow_spec_result_;
  _impl_.tensorflow_spec_result_ = nullptr;
  return temp;
}
inline ::google::internal::federated::plan::TensorflowSpec* ServerPhaseV2::_internal_mutable_tensorflow_spec_result() {

  if (_impl_.tensorflow_spec_result_ == nullptr) {
    auto* p = CreateMaybeMessage<::google::internal::federated::plan::TensorflowSpec>(GetArenaForAllocation());
    _impl_.tensorflow_spec_result_ = p;
  }
  return _impl_.tensorflow_spec_result_;
}
inline ::google::internal::federated::plan::TensorflowSpec* ServerPhaseV2::mutable_tensorflow_spec_result() {
  ::google::internal::federated::plan::TensorflowSpec* _msg = _internal_mutable_tensorflow_spec_result();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerPhaseV2.tensorflow_spec_result)
  return _msg;
}
inline void ServerPhaseV2::set_allocated_tensorflow_spec_result(::google::internal::federated::plan::TensorflowSpec* tensorflow_spec_result) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.tensorflow_spec_result_;
  }
  if (tensorflow_spec_result) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(tensorflow_spec_result);
    if (message_arena != submessage_arena) {
      tensorflow_spec_result = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, tensorflow_spec_result, submessage_arena);
    }

  } else {

  }
  _impl_.tensorflow_spec_result_ = tensorflow_spec_result;
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ServerPhaseV2.tensorflow_spec_result)
}

// .google.internal.federated.plan.ServerResultIORouter result_router = 6;
inline bool ServerPhaseV2::_internal_has_result_router() const {
  return server_result_io_router_case() == kResultRouter;
}
inline bool ServerPhaseV2::has_result_router() const {
  return _internal_has_result_router();
}
inline void ServerPhaseV2::set_has_result_router() {
  _impl_._oneof_case_[1] = kResultRouter;
}
inline void ServerPhaseV2::clear_result_router() {
  if (_internal_has_result_router()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.server_result_io_router_.result_router_;
    }
    clear_has_server_result_io_router();
  }
}
inline ::google::internal::federated::plan::ServerResultIORouter* ServerPhaseV2::release_result_router() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ServerPhaseV2.result_router)
  if (_internal_has_result_router()) {
    clear_has_server_result_io_router();
    ::google::internal::federated::plan::ServerResultIORouter* temp = _impl_.server_result_io_router_.result_router_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.server_result_io_router_.result_router_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::google::internal::federated::plan::ServerResultIORouter& ServerPhaseV2::_internal_result_router() const {
  return _internal_has_result_router()
      ? *_impl_.server_result_io_router_.result_router_
      : reinterpret_cast< ::google::internal::federated::plan::ServerResultIORouter&>(::google::internal::federated::plan::_ServerResultIORouter_default_instance_);
}
inline const ::google::internal::federated::plan::ServerResultIORouter& ServerPhaseV2::result_router() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerPhaseV2.result_router)
  return _internal_result_router();
}
inline ::google::internal::federated::plan::ServerResultIORouter* ServerPhaseV2::unsafe_arena_release_result_router() {
  // @@protoc_insertion_point(field_unsafe_arena_release:google.internal.federated.plan.ServerPhaseV2.result_router)
  if (_internal_has_result_router()) {
    clear_has_server_result_io_router();
    ::google::internal::federated::plan::ServerResultIORouter* temp = _impl_.server_result_io_router_.result_router_;
    _impl_.server_result_io_router_.result_router_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ServerPhaseV2::unsafe_arena_set_allocated_result_router(::google::internal::federated::plan::ServerResultIORouter* result_router) {
  clear_server_result_io_router();
  if (result_router) {
    set_has_result_router();
    _impl_.server_result_io_router_.result_router_ = result_router;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.ServerPhaseV2.result_router)
}
inline ::google::internal::federated::plan::ServerResultIORouter* ServerPhaseV2::_internal_mutable_result_router() {
  if (!_internal_has_result_router()) {
    clear_server_result_io_router();
    set_has_result_router();
    _impl_.server_result_io_router_.result_router_ = CreateMaybeMessage< ::google::internal::federated::plan::ServerResultIORouter >(GetArenaForAllocation());
  }
  return _impl_.server_result_io_router_.result_router_;
}
inline ::google::internal::federated::plan::ServerResultIORouter* ServerPhaseV2::mutable_result_router() {
  ::google::internal::federated::plan::ServerResultIORouter* _msg = _internal_mutable_result_router();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerPhaseV2.result_router)
  return _msg;
}

inline bool ServerPhaseV2::has_server_prepare_io_router() const {
  return server_prepare_io_router_case() != SERVER_PREPARE_IO_ROUTER_NOT_SET;
}
inline void ServerPhaseV2::clear_has_server_prepare_io_router() {
  _impl_._oneof_case_[0] = SERVER_PREPARE_IO_ROUTER_NOT_SET;
}
inline bool ServerPhaseV2::has_server_result_io_router() const {
  return server_result_io_router_case() != SERVER_RESULT_IO_ROUTER_NOT_SET;
}
inline void ServerPhaseV2::clear_has_server_result_io_router() {
  _impl_._oneof_case_[1] = SERVER_RESULT_IO_ROUTER_NOT_SET;
}
inline ServerPhaseV2::ServerPrepareIoRouterCase ServerPhaseV2::server_prepare_io_router_case() const {
  return ServerPhaseV2::ServerPrepareIoRouterCase(_impl_._oneof_case_[0]);
}
inline ServerPhaseV2::ServerResultIoRouterCase ServerPhaseV2::server_result_io_router_case() const {
  return ServerPhaseV2::ServerResultIoRouterCase(_impl_._oneof_case_[1]);
}
// -------------------------------------------------------------------

// ServerPrepareIORouter

// string prepare_server_state_input_filepath_tensor_name = 1;
inline void ServerPrepareIORouter::clear_prepare_server_state_input_filepath_tensor_name() {
  _impl_.prepare_server_state_input_filepath_tensor_name_.ClearToEmpty();
}
inline const std::string& ServerPrepareIORouter::prepare_server_state_input_filepath_tensor_name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerPrepareIORouter.prepare_server_state_input_filepath_tensor_name)
  return _internal_prepare_server_state_input_filepath_tensor_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ServerPrepareIORouter::set_prepare_server_state_input_filepath_tensor_name(ArgT0&& arg0, ArgT... args) {

 _impl_.prepare_server_state_input_filepath_tensor_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.ServerPrepareIORouter.prepare_server_state_input_filepath_tensor_name)
}
inline std::string* ServerPrepareIORouter::mutable_prepare_server_state_input_filepath_tensor_name() {
  std::string* _s = _internal_mutable_prepare_server_state_input_filepath_tensor_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerPrepareIORouter.prepare_server_state_input_filepath_tensor_name)
  return _s;
}
inline const std::string& ServerPrepareIORouter::_internal_prepare_server_state_input_filepath_tensor_name() const {
  return _impl_.prepare_server_state_input_filepath_tensor_name_.Get();
}
inline void ServerPrepareIORouter::_internal_set_prepare_server_state_input_filepath_tensor_name(const std::string& value) {

  _impl_.prepare_server_state_input_filepath_tensor_name_.Set(value, GetArenaForAllocation());
}
inline std::string* ServerPrepareIORouter::_internal_mutable_prepare_server_state_input_filepath_tensor_name() {

  return _impl_.prepare_server_state_input_filepath_tensor_name_.Mutable(GetArenaForAllocation());
}
inline std::string* ServerPrepareIORouter::release_prepare_server_state_input_filepath_tensor_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ServerPrepareIORouter.prepare_server_state_input_filepath_tensor_name)
  return _impl_.prepare_server_state_input_filepath_tensor_name_.Release();
}
inline void ServerPrepareIORouter::set_allocated_prepare_server_state_input_filepath_tensor_name(std::string* prepare_server_state_input_filepath_tensor_name) {
  _impl_.prepare_server_state_input_filepath_tensor_name_.SetAllocated(prepare_server_state_input_filepath_tensor_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.prepare_server_state_input_filepath_tensor_name_.IsDefault()) {
    _impl_.prepare_server_state_input_filepath_tensor_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ServerPrepareIORouter.prepare_server_state_input_filepath_tensor_name)
}

// string prepare_output_filepath_tensor_name = 2;
inline void ServerPrepareIORouter::clear_prepare_output_filepath_tensor_name() {
  _impl_.prepare_output_filepath_tensor_name_.ClearToEmpty();
}
inline const std::string& ServerPrepareIORouter::prepare_output_filepath_tensor_name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerPrepareIORouter.prepare_output_filepath_tensor_name)
  return _internal_prepare_output_filepath_tensor_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ServerPrepareIORouter::set_prepare_output_filepath_tensor_name(ArgT0&& arg0, ArgT... args) {

 _impl_.prepare_output_filepath_tensor_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.ServerPrepareIORouter.prepare_output_filepath_tensor_name)
}
inline std::string* ServerPrepareIORouter::mutable_prepare_output_filepath_tensor_name() {
  std::string* _s = _internal_mutable_prepare_output_filepath_tensor_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerPrepareIORouter.prepare_output_filepath_tensor_name)
  return _s;
}
inline const std::string& ServerPrepareIORouter::_internal_prepare_output_filepath_tensor_name() const {
  return _impl_.prepare_output_filepath_tensor_name_.Get();
}
inline void ServerPrepareIORouter::_internal_set_prepare_output_filepath_tensor_name(const std::string& value) {

  _impl_.prepare_output_filepath_tensor_name_.Set(value, GetArenaForAllocation());
}
inline std::string* ServerPrepareIORouter::_internal_mutable_prepare_output_filepath_tensor_name() {

  return _impl_.prepare_output_filepath_tensor_name_.Mutable(GetArenaForAllocation());
}
inline std::string* ServerPrepareIORouter::release_prepare_output_filepath_tensor_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ServerPrepareIORouter.prepare_output_filepath_tensor_name)
  return _impl_.prepare_output_filepath_tensor_name_.Release();
}
inline void ServerPrepareIORouter::set_allocated_prepare_output_filepath_tensor_name(std::string* prepare_output_filepath_tensor_name) {
  _impl_.prepare_output_filepath_tensor_name_.SetAllocated(prepare_output_filepath_tensor_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.prepare_output_filepath_tensor_name_.IsDefault()) {
    _impl_.prepare_output_filepath_tensor_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ServerPrepareIORouter.prepare_output_filepath_tensor_name)
}

// string prepare_intermediate_state_output_filepath_tensor_name = 3;
inline void ServerPrepareIORouter::clear_prepare_intermediate_state_output_filepath_tensor_name() {
  _impl_.prepare_intermediate_state_output_filepath_tensor_name_.ClearToEmpty();
}
inline const std::string& ServerPrepareIORouter::prepare_intermediate_state_output_filepath_tensor_name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerPrepareIORouter.prepare_intermediate_state_output_filepath_tensor_name)
  return _internal_prepare_intermediate_state_output_filepath_tensor_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ServerPrepareIORouter::set_prepare_intermediate_state_output_filepath_tensor_name(ArgT0&& arg0, ArgT... args) {

 _impl_.prepare_intermediate_state_output_filepath_tensor_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.ServerPrepareIORouter.prepare_intermediate_state_output_filepath_tensor_name)
}
inline std::string* ServerPrepareIORouter::mutable_prepare_intermediate_state_output_filepath_tensor_name() {
  std::string* _s = _internal_mutable_prepare_intermediate_state_output_filepath_tensor_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerPrepareIORouter.prepare_intermediate_state_output_filepath_tensor_name)
  return _s;
}
inline const std::string& ServerPrepareIORouter::_internal_prepare_intermediate_state_output_filepath_tensor_name() const {
  return _impl_.prepare_intermediate_state_output_filepath_tensor_name_.Get();
}
inline void ServerPrepareIORouter::_internal_set_prepare_intermediate_state_output_filepath_tensor_name(const std::string& value) {

  _impl_.prepare_intermediate_state_output_filepath_tensor_name_.Set(value, GetArenaForAllocation());
}
inline std::string* ServerPrepareIORouter::_internal_mutable_prepare_intermediate_state_output_filepath_tensor_name() {

  return _impl_.prepare_intermediate_state_output_filepath_tensor_name_.Mutable(GetArenaForAllocation());
}
inline std::string* ServerPrepareIORouter::release_prepare_intermediate_state_output_filepath_tensor_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ServerPrepareIORouter.prepare_intermediate_state_output_filepath_tensor_name)
  return _impl_.prepare_intermediate_state_output_filepath_tensor_name_.Release();
}
inline void ServerPrepareIORouter::set_allocated_prepare_intermediate_state_output_filepath_tensor_name(std::string* prepare_intermediate_state_output_filepath_tensor_name) {
  _impl_.prepare_intermediate_state_output_filepath_tensor_name_.SetAllocated(prepare_intermediate_state_output_filepath_tensor_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.prepare_intermediate_state_output_filepath_tensor_name_.IsDefault()) {
    _impl_.prepare_intermediate_state_output_filepath_tensor_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ServerPrepareIORouter.prepare_intermediate_state_output_filepath_tensor_name)
}

// -------------------------------------------------------------------

// ServerResultIORouter

// string result_intermediate_state_input_filepath_tensor_name = 1;
inline void ServerResultIORouter::clear_result_intermediate_state_input_filepath_tensor_name() {
  _impl_.result_intermediate_state_input_filepath_tensor_name_.ClearToEmpty();
}
inline const std::string& ServerResultIORouter::result_intermediate_state_input_filepath_tensor_name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerResultIORouter.result_intermediate_state_input_filepath_tensor_name)
  return _internal_result_intermediate_state_input_filepath_tensor_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ServerResultIORouter::set_result_intermediate_state_input_filepath_tensor_name(ArgT0&& arg0, ArgT... args) {

 _impl_.result_intermediate_state_input_filepath_tensor_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.ServerResultIORouter.result_intermediate_state_input_filepath_tensor_name)
}
inline std::string* ServerResultIORouter::mutable_result_intermediate_state_input_filepath_tensor_name() {
  std::string* _s = _internal_mutable_result_intermediate_state_input_filepath_tensor_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerResultIORouter.result_intermediate_state_input_filepath_tensor_name)
  return _s;
}
inline const std::string& ServerResultIORouter::_internal_result_intermediate_state_input_filepath_tensor_name() const {
  return _impl_.result_intermediate_state_input_filepath_tensor_name_.Get();
}
inline void ServerResultIORouter::_internal_set_result_intermediate_state_input_filepath_tensor_name(const std::string& value) {

  _impl_.result_intermediate_state_input_filepath_tensor_name_.Set(value, GetArenaForAllocation());
}
inline std::string* ServerResultIORouter::_internal_mutable_result_intermediate_state_input_filepath_tensor_name() {

  return _impl_.result_intermediate_state_input_filepath_tensor_name_.Mutable(GetArenaForAllocation());
}
inline std::string* ServerResultIORouter::release_result_intermediate_state_input_filepath_tensor_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ServerResultIORouter.result_intermediate_state_input_filepath_tensor_name)
  return _impl_.result_intermediate_state_input_filepath_tensor_name_.Release();
}
inline void ServerResultIORouter::set_allocated_result_intermediate_state_input_filepath_tensor_name(std::string* result_intermediate_state_input_filepath_tensor_name) {
  _impl_.result_intermediate_state_input_filepath_tensor_name_.SetAllocated(result_intermediate_state_input_filepath_tensor_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.result_intermediate_state_input_filepath_tensor_name_.IsDefault()) {
    _impl_.result_intermediate_state_input_filepath_tensor_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ServerResultIORouter.result_intermediate_state_input_filepath_tensor_name)
}

// string result_aggregate_result_input_filepath_tensor_name = 2;
inline void ServerResultIORouter::clear_result_aggregate_result_input_filepath_tensor_name() {
  _impl_.result_aggregate_result_input_filepath_tensor_name_.ClearToEmpty();
}
inline const std::string& ServerResultIORouter::result_aggregate_result_input_filepath_tensor_name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerResultIORouter.result_aggregate_result_input_filepath_tensor_name)
  return _internal_result_aggregate_result_input_filepath_tensor_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ServerResultIORouter::set_result_aggregate_result_input_filepath_tensor_name(ArgT0&& arg0, ArgT... args) {

 _impl_.result_aggregate_result_input_filepath_tensor_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.ServerResultIORouter.result_aggregate_result_input_filepath_tensor_name)
}
inline std::string* ServerResultIORouter::mutable_result_aggregate_result_input_filepath_tensor_name() {
  std::string* _s = _internal_mutable_result_aggregate_result_input_filepath_tensor_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerResultIORouter.result_aggregate_result_input_filepath_tensor_name)
  return _s;
}
inline const std::string& ServerResultIORouter::_internal_result_aggregate_result_input_filepath_tensor_name() const {
  return _impl_.result_aggregate_result_input_filepath_tensor_name_.Get();
}
inline void ServerResultIORouter::_internal_set_result_aggregate_result_input_filepath_tensor_name(const std::string& value) {

  _impl_.result_aggregate_result_input_filepath_tensor_name_.Set(value, GetArenaForAllocation());
}
inline std::string* ServerResultIORouter::_internal_mutable_result_aggregate_result_input_filepath_tensor_name() {

  return _impl_.result_aggregate_result_input_filepath_tensor_name_.Mutable(GetArenaForAllocation());
}
inline std::string* ServerResultIORouter::release_result_aggregate_result_input_filepath_tensor_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ServerResultIORouter.result_aggregate_result_input_filepath_tensor_name)
  return _impl_.result_aggregate_result_input_filepath_tensor_name_.Release();
}
inline void ServerResultIORouter::set_allocated_result_aggregate_result_input_filepath_tensor_name(std::string* result_aggregate_result_input_filepath_tensor_name) {
  _impl_.result_aggregate_result_input_filepath_tensor_name_.SetAllocated(result_aggregate_result_input_filepath_tensor_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.result_aggregate_result_input_filepath_tensor_name_.IsDefault()) {
    _impl_.result_aggregate_result_input_filepath_tensor_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ServerResultIORouter.result_aggregate_result_input_filepath_tensor_name)
}

// string result_server_state_output_filepath_tensor_name = 3;
inline void ServerResultIORouter::clear_result_server_state_output_filepath_tensor_name() {
  _impl_.result_server_state_output_filepath_tensor_name_.ClearToEmpty();
}
inline const std::string& ServerResultIORouter::result_server_state_output_filepath_tensor_name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerResultIORouter.result_server_state_output_filepath_tensor_name)
  return _internal_result_server_state_output_filepath_tensor_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ServerResultIORouter::set_result_server_state_output_filepath_tensor_name(ArgT0&& arg0, ArgT... args) {

 _impl_.result_server_state_output_filepath_tensor_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.ServerResultIORouter.result_server_state_output_filepath_tensor_name)
}
inline std::string* ServerResultIORouter::mutable_result_server_state_output_filepath_tensor_name() {
  std::string* _s = _internal_mutable_result_server_state_output_filepath_tensor_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerResultIORouter.result_server_state_output_filepath_tensor_name)
  return _s;
}
inline const std::string& ServerResultIORouter::_internal_result_server_state_output_filepath_tensor_name() const {
  return _impl_.result_server_state_output_filepath_tensor_name_.Get();
}
inline void ServerResultIORouter::_internal_set_result_server_state_output_filepath_tensor_name(const std::string& value) {

  _impl_.result_server_state_output_filepath_tensor_name_.Set(value, GetArenaForAllocation());
}
inline std::string* ServerResultIORouter::_internal_mutable_result_server_state_output_filepath_tensor_name() {

  return _impl_.result_server_state_output_filepath_tensor_name_.Mutable(GetArenaForAllocation());
}
inline std::string* ServerResultIORouter::release_result_server_state_output_filepath_tensor_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ServerResultIORouter.result_server_state_output_filepath_tensor_name)
  return _impl_.result_server_state_output_filepath_tensor_name_.Release();
}
inline void ServerResultIORouter::set_allocated_result_server_state_output_filepath_tensor_name(std::string* result_server_state_output_filepath_tensor_name) {
  _impl_.result_server_state_output_filepath_tensor_name_.SetAllocated(result_server_state_output_filepath_tensor_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.result_server_state_output_filepath_tensor_name_.IsDefault()) {
    _impl_.result_server_state_output_filepath_tensor_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ServerResultIORouter.result_server_state_output_filepath_tensor_name)
}

// -------------------------------------------------------------------

// ServerAggregationConfig_IntrinsicArg

// .tensorflow.TensorSpecProto input_tensor = 2;
inline bool ServerAggregationConfig_IntrinsicArg::_internal_has_input_tensor() const {
  return arg_case() == kInputTensor;
}
inline bool ServerAggregationConfig_IntrinsicArg::has_input_tensor() const {
  return _internal_has_input_tensor();
}
inline void ServerAggregationConfig_IntrinsicArg::set_has_input_tensor() {
  _impl_._oneof_case_[0] = kInputTensor;
}
inline ::tensorflow::TensorSpecProto* ServerAggregationConfig_IntrinsicArg::release_input_tensor() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ServerAggregationConfig.IntrinsicArg.input_tensor)
  if (_internal_has_input_tensor()) {
    clear_has_arg();
    ::tensorflow::TensorSpecProto* temp = _impl_.arg_.input_tensor_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.arg_.input_tensor_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::tensorflow::TensorSpecProto& ServerAggregationConfig_IntrinsicArg::_internal_input_tensor() const {
  return _internal_has_input_tensor()
      ? *_impl_.arg_.input_tensor_
      : reinterpret_cast< ::tensorflow::TensorSpecProto&>(::tensorflow::_TensorSpecProto_default_instance_);
}
inline const ::tensorflow::TensorSpecProto& ServerAggregationConfig_IntrinsicArg::input_tensor() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerAggregationConfig.IntrinsicArg.input_tensor)
  return _internal_input_tensor();
}
inline ::tensorflow::TensorSpecProto* ServerAggregationConfig_IntrinsicArg::unsafe_arena_release_input_tensor() {
  // @@protoc_insertion_point(field_unsafe_arena_release:google.internal.federated.plan.ServerAggregationConfig.IntrinsicArg.input_tensor)
  if (_internal_has_input_tensor()) {
    clear_has_arg();
    ::tensorflow::TensorSpecProto* temp = _impl_.arg_.input_tensor_;
    _impl_.arg_.input_tensor_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ServerAggregationConfig_IntrinsicArg::unsafe_arena_set_allocated_input_tensor(::tensorflow::TensorSpecProto* input_tensor) {
  clear_arg();
  if (input_tensor) {
    set_has_input_tensor();
    _impl_.arg_.input_tensor_ = input_tensor;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.ServerAggregationConfig.IntrinsicArg.input_tensor)
}
inline ::tensorflow::TensorSpecProto* ServerAggregationConfig_IntrinsicArg::_internal_mutable_input_tensor() {
  if (!_internal_has_input_tensor()) {
    clear_arg();
    set_has_input_tensor();
    _impl_.arg_.input_tensor_ = CreateMaybeMessage< ::tensorflow::TensorSpecProto >(GetArenaForAllocation());
  }
  return _impl_.arg_.input_tensor_;
}
inline ::tensorflow::TensorSpecProto* ServerAggregationConfig_IntrinsicArg::mutable_input_tensor() {
  ::tensorflow::TensorSpecProto* _msg = _internal_mutable_input_tensor();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerAggregationConfig.IntrinsicArg.input_tensor)
  return _msg;
}

// .tensorflow.TensorSpecProto state_tensor = 3;
inline bool ServerAggregationConfig_IntrinsicArg::_internal_has_state_tensor() const {
  return arg_case() == kStateTensor;
}
inline bool ServerAggregationConfig_IntrinsicArg::has_state_tensor() const {
  return _internal_has_state_tensor();
}
inline void ServerAggregationConfig_IntrinsicArg::set_has_state_tensor() {
  _impl_._oneof_case_[0] = kStateTensor;
}
inline ::tensorflow::TensorSpecProto* ServerAggregationConfig_IntrinsicArg::release_state_tensor() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ServerAggregationConfig.IntrinsicArg.state_tensor)
  if (_internal_has_state_tensor()) {
    clear_has_arg();
    ::tensorflow::TensorSpecProto* temp = _impl_.arg_.state_tensor_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.arg_.state_tensor_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::tensorflow::TensorSpecProto& ServerAggregationConfig_IntrinsicArg::_internal_state_tensor() const {
  return _internal_has_state_tensor()
      ? *_impl_.arg_.state_tensor_
      : reinterpret_cast< ::tensorflow::TensorSpecProto&>(::tensorflow::_TensorSpecProto_default_instance_);
}
inline const ::tensorflow::TensorSpecProto& ServerAggregationConfig_IntrinsicArg::state_tensor() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerAggregationConfig.IntrinsicArg.state_tensor)
  return _internal_state_tensor();
}
inline ::tensorflow::TensorSpecProto* ServerAggregationConfig_IntrinsicArg::unsafe_arena_release_state_tensor() {
  // @@protoc_insertion_point(field_unsafe_arena_release:google.internal.federated.plan.ServerAggregationConfig.IntrinsicArg.state_tensor)
  if (_internal_has_state_tensor()) {
    clear_has_arg();
    ::tensorflow::TensorSpecProto* temp = _impl_.arg_.state_tensor_;
    _impl_.arg_.state_tensor_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ServerAggregationConfig_IntrinsicArg::unsafe_arena_set_allocated_state_tensor(::tensorflow::TensorSpecProto* state_tensor) {
  clear_arg();
  if (state_tensor) {
    set_has_state_tensor();
    _impl_.arg_.state_tensor_ = state_tensor;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.ServerAggregationConfig.IntrinsicArg.state_tensor)
}
inline ::tensorflow::TensorSpecProto* ServerAggregationConfig_IntrinsicArg::_internal_mutable_state_tensor() {
  if (!_internal_has_state_tensor()) {
    clear_arg();
    set_has_state_tensor();
    _impl_.arg_.state_tensor_ = CreateMaybeMessage< ::tensorflow::TensorSpecProto >(GetArenaForAllocation());
  }
  return _impl_.arg_.state_tensor_;
}
inline ::tensorflow::TensorSpecProto* ServerAggregationConfig_IntrinsicArg::mutable_state_tensor() {
  ::tensorflow::TensorSpecProto* _msg = _internal_mutable_state_tensor();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerAggregationConfig.IntrinsicArg.state_tensor)
  return _msg;
}

inline bool ServerAggregationConfig_IntrinsicArg::has_arg() const {
  return arg_case() != ARG_NOT_SET;
}
inline void ServerAggregationConfig_IntrinsicArg::clear_has_arg() {
  _impl_._oneof_case_[0] = ARG_NOT_SET;
}
inline ServerAggregationConfig_IntrinsicArg::ArgCase ServerAggregationConfig_IntrinsicArg::arg_case() const {
  return ServerAggregationConfig_IntrinsicArg::ArgCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// ServerAggregationConfig

// string intrinsic_uri = 1;
inline void ServerAggregationConfig::clear_intrinsic_uri() {
  _impl_.intrinsic_uri_.ClearToEmpty();
}
inline const std::string& ServerAggregationConfig::intrinsic_uri() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerAggregationConfig.intrinsic_uri)
  return _internal_intrinsic_uri();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ServerAggregationConfig::set_intrinsic_uri(ArgT0&& arg0, ArgT... args) {

 _impl_.intrinsic_uri_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.ServerAggregationConfig.intrinsic_uri)
}
inline std::string* ServerAggregationConfig::mutable_intrinsic_uri() {
  std::string* _s = _internal_mutable_intrinsic_uri();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerAggregationConfig.intrinsic_uri)
  return _s;
}
inline const std::string& ServerAggregationConfig::_internal_intrinsic_uri() const {
  return _impl_.intrinsic_uri_.Get();
}
inline void ServerAggregationConfig::_internal_set_intrinsic_uri(const std::string& value) {

  _impl_.intrinsic_uri_.Set(value, GetArenaForAllocation());
}
inline std::string* ServerAggregationConfig::_internal_mutable_intrinsic_uri() {

  return _impl_.intrinsic_uri_.Mutable(GetArenaForAllocation());
}
inline std::string* ServerAggregationConfig::release_intrinsic_uri() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ServerAggregationConfig.intrinsic_uri)
  return _impl_.intrinsic_uri_.Release();
}
inline void ServerAggregationConfig::set_allocated_intrinsic_uri(std::string* intrinsic_uri) {
  _impl_.intrinsic_uri_.SetAllocated(intrinsic_uri, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.intrinsic_uri_.IsDefault()) {
    _impl_.intrinsic_uri_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ServerAggregationConfig.intrinsic_uri)
}

// repeated .google.internal.federated.plan.ServerAggregationConfig.IntrinsicArg intrinsic_args = 4;
inline int ServerAggregationConfig::_internal_intrinsic_args_size() const {
  return _impl_.intrinsic_args_.size();
}
inline int ServerAggregationConfig::intrinsic_args_size() const {
  return _internal_intrinsic_args_size();
}
inline void ServerAggregationConfig::clear_intrinsic_args() {
  _impl_.intrinsic_args_.Clear();
}
inline ::google::internal::federated::plan::ServerAggregationConfig_IntrinsicArg* ServerAggregationConfig::mutable_intrinsic_args(int index) {
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerAggregationConfig.intrinsic_args)
  return _impl_.intrinsic_args_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::ServerAggregationConfig_IntrinsicArg >*
ServerAggregationConfig::mutable_intrinsic_args() {
  // @@protoc_insertion_point(field_mutable_list:google.internal.federated.plan.ServerAggregationConfig.intrinsic_args)
  return &_impl_.intrinsic_args_;
}
inline const ::google::internal::federated::plan::ServerAggregationConfig_IntrinsicArg& ServerAggregationConfig::_internal_intrinsic_args(int index) const {
  return _impl_.intrinsic_args_.Get(index);
}
inline const ::google::internal::federated::plan::ServerAggregationConfig_IntrinsicArg& ServerAggregationConfig::intrinsic_args(int index) const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerAggregationConfig.intrinsic_args)
  return _internal_intrinsic_args(index);
}
inline ::google::internal::federated::plan::ServerAggregationConfig_IntrinsicArg* ServerAggregationConfig::_internal_add_intrinsic_args() {
  return _impl_.intrinsic_args_.Add();
}
inline ::google::internal::federated::plan::ServerAggregationConfig_IntrinsicArg* ServerAggregationConfig::add_intrinsic_args() {
  ::google::internal::federated::plan::ServerAggregationConfig_IntrinsicArg* _add = _internal_add_intrinsic_args();
  // @@protoc_insertion_point(field_add:google.internal.federated.plan.ServerAggregationConfig.intrinsic_args)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::ServerAggregationConfig_IntrinsicArg >&
ServerAggregationConfig::intrinsic_args() const {
  // @@protoc_insertion_point(field_list:google.internal.federated.plan.ServerAggregationConfig.intrinsic_args)
  return _impl_.intrinsic_args_;
}

// repeated .tensorflow.TensorSpecProto output_tensors = 5;
inline int ServerAggregationConfig::_internal_output_tensors_size() const {
  return _impl_.output_tensors_.size();
}
inline int ServerAggregationConfig::output_tensors_size() const {
  return _internal_output_tensors_size();
}
inline ::tensorflow::TensorSpecProto* ServerAggregationConfig::mutable_output_tensors(int index) {
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerAggregationConfig.output_tensors)
  return _impl_.output_tensors_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorSpecProto >*
ServerAggregationConfig::mutable_output_tensors() {
  // @@protoc_insertion_point(field_mutable_list:google.internal.federated.plan.ServerAggregationConfig.output_tensors)
  return &_impl_.output_tensors_;
}
inline const ::tensorflow::TensorSpecProto& ServerAggregationConfig::_internal_output_tensors(int index) const {
  return _impl_.output_tensors_.Get(index);
}
inline const ::tensorflow::TensorSpecProto& ServerAggregationConfig::output_tensors(int index) const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerAggregationConfig.output_tensors)
  return _internal_output_tensors(index);
}
inline ::tensorflow::TensorSpecProto* ServerAggregationConfig::_internal_add_output_tensors() {
  return _impl_.output_tensors_.Add();
}
inline ::tensorflow::TensorSpecProto* ServerAggregationConfig::add_output_tensors() {
  ::tensorflow::TensorSpecProto* _add = _internal_add_output_tensors();
  // @@protoc_insertion_point(field_add:google.internal.federated.plan.ServerAggregationConfig.output_tensors)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorSpecProto >&
ServerAggregationConfig::output_tensors() const {
  // @@protoc_insertion_point(field_list:google.internal.federated.plan.ServerAggregationConfig.output_tensors)
  return _impl_.output_tensors_;
}

// repeated .google.internal.federated.plan.ServerAggregationConfig inner_aggregations = 6;
inline int ServerAggregationConfig::_internal_inner_aggregations_size() const {
  return _impl_.inner_aggregations_.size();
}
inline int ServerAggregationConfig::inner_aggregations_size() const {
  return _internal_inner_aggregations_size();
}
inline void ServerAggregationConfig::clear_inner_aggregations() {
  _impl_.inner_aggregations_.Clear();
}
inline ::google::internal::federated::plan::ServerAggregationConfig* ServerAggregationConfig::mutable_inner_aggregations(int index) {
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerAggregationConfig.inner_aggregations)
  return _impl_.inner_aggregations_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::ServerAggregationConfig >*
ServerAggregationConfig::mutable_inner_aggregations() {
  // @@protoc_insertion_point(field_mutable_list:google.internal.federated.plan.ServerAggregationConfig.inner_aggregations)
  return &_impl_.inner_aggregations_;
}
inline const ::google::internal::federated::plan::ServerAggregationConfig& ServerAggregationConfig::_internal_inner_aggregations(int index) const {
  return _impl_.inner_aggregations_.Get(index);
}
inline const ::google::internal::federated::plan::ServerAggregationConfig& ServerAggregationConfig::inner_aggregations(int index) const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerAggregationConfig.inner_aggregations)
  return _internal_inner_aggregations(index);
}
inline ::google::internal::federated::plan::ServerAggregationConfig* ServerAggregationConfig::_internal_add_inner_aggregations() {
  return _impl_.inner_aggregations_.Add();
}
inline ::google::internal::federated::plan::ServerAggregationConfig* ServerAggregationConfig::add_inner_aggregations() {
  ::google::internal::federated::plan::ServerAggregationConfig* _add = _internal_add_inner_aggregations();
  // @@protoc_insertion_point(field_add:google.internal.federated.plan.ServerAggregationConfig.inner_aggregations)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::ServerAggregationConfig >&
ServerAggregationConfig::inner_aggregations() const {
  // @@protoc_insertion_point(field_list:google.internal.federated.plan.ServerAggregationConfig.inner_aggregations)
  return _impl_.inner_aggregations_;
}

// -------------------------------------------------------------------

// ServerPhase

// string name = 8;
inline void ServerPhase::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& ServerPhase::name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerPhase.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ServerPhase::set_name(ArgT0&& arg0, ArgT... args) {

 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.ServerPhase.name)
}
inline std::string* ServerPhase::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerPhase.name)
  return _s;
}
inline const std::string& ServerPhase::_internal_name() const {
  return _impl_.name_.Get();
}
inline void ServerPhase::_internal_set_name(const std::string& value) {

  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* ServerPhase::_internal_mutable_name() {

  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* ServerPhase::release_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ServerPhase.name)
  return _impl_.name_.Release();
}
inline void ServerPhase::set_allocated_name(std::string* name) {
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ServerPhase.name)
}

// string phase_init_op = 1;
inline void ServerPhase::clear_phase_init_op() {
  _impl_.phase_init_op_.ClearToEmpty();
}
inline const std::string& ServerPhase::phase_init_op() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerPhase.phase_init_op)
  return _internal_phase_init_op();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ServerPhase::set_phase_init_op(ArgT0&& arg0, ArgT... args) {

 _impl_.phase_init_op_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.ServerPhase.phase_init_op)
}
inline std::string* ServerPhase::mutable_phase_init_op() {
  std::string* _s = _internal_mutable_phase_init_op();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerPhase.phase_init_op)
  return _s;
}
inline const std::string& ServerPhase::_internal_phase_init_op() const {
  return _impl_.phase_init_op_.Get();
}
inline void ServerPhase::_internal_set_phase_init_op(const std::string& value) {

  _impl_.phase_init_op_.Set(value, GetArenaForAllocation());
}
inline std::string* ServerPhase::_internal_mutable_phase_init_op() {

  return _impl_.phase_init_op_.Mutable(GetArenaForAllocation());
}
inline std::string* ServerPhase::release_phase_init_op() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ServerPhase.phase_init_op)
  return _impl_.phase_init_op_.Release();
}
inline void ServerPhase::set_allocated_phase_init_op(std::string* phase_init_op) {
  _impl_.phase_init_op_.SetAllocated(phase_init_op, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.phase_init_op_.IsDefault()) {
    _impl_.phase_init_op_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ServerPhase.phase_init_op)
}

// .google.internal.federated.plan.CheckpointOp read_update = 3;
inline bool ServerPhase::_internal_has_read_update() const {
  return this != internal_default_instance() && _impl_.read_update_ != nullptr;
}
inline bool ServerPhase::has_read_update() const {
  return _internal_has_read_update();
}
inline void ServerPhase::clear_read_update() {
  if (GetArenaForAllocation() == nullptr && _impl_.read_update_ != nullptr) {
    delete _impl_.read_update_;
  }
  _impl_.read_update_ = nullptr;
}
inline const ::google::internal::federated::plan::CheckpointOp& ServerPhase::_internal_read_update() const {
  const ::google::internal::federated::plan::CheckpointOp* p = _impl_.read_update_;
  return p != nullptr ? *p : reinterpret_cast<const ::google::internal::federated::plan::CheckpointOp&>(
      ::google::internal::federated::plan::_CheckpointOp_default_instance_);
}
inline const ::google::internal::federated::plan::CheckpointOp& ServerPhase::read_update() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerPhase.read_update)
  return _internal_read_update();
}
inline void ServerPhase::unsafe_arena_set_allocated_read_update(
    ::google::internal::federated::plan::CheckpointOp* read_update) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.read_update_);
  }
  _impl_.read_update_ = read_update;
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.ServerPhase.read_update)
}
inline ::google::internal::federated::plan::CheckpointOp* ServerPhase::release_read_update() {

  ::google::internal::federated::plan::CheckpointOp* temp = _impl_.read_update_;
  _impl_.read_update_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::google::internal::federated::plan::CheckpointOp* ServerPhase::unsafe_arena_release_read_update() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ServerPhase.read_update)

  ::google::internal::federated::plan::CheckpointOp* temp = _impl_.read_update_;
  _impl_.read_update_ = nullptr;
  return temp;
}
inline ::google::internal::federated::plan::CheckpointOp* ServerPhase::_internal_mutable_read_update() {

  if (_impl_.read_update_ == nullptr) {
    auto* p = CreateMaybeMessage<::google::internal::federated::plan::CheckpointOp>(GetArenaForAllocation());
    _impl_.read_update_ = p;
  }
  return _impl_.read_update_;
}
inline ::google::internal::federated::plan::CheckpointOp* ServerPhase::mutable_read_update() {
  ::google::internal::federated::plan::CheckpointOp* _msg = _internal_mutable_read_update();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerPhase.read_update)
  return _msg;
}
inline void ServerPhase::set_allocated_read_update(::google::internal::federated::plan::CheckpointOp* read_update) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.read_update_;
  }
  if (read_update) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(read_update);
    if (message_arena != submessage_arena) {
      read_update = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, read_update, submessage_arena);
    }

  } else {

  }
  _impl_.read_update_ = read_update;
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ServerPhase.read_update)
}

// string aggregate_into_accumulators_op = 4;
inline void ServerPhase::clear_aggregate_into_accumulators_op() {
  _impl_.aggregate_into_accumulators_op_.ClearToEmpty();
}
inline const std::string& ServerPhase::aggregate_into_accumulators_op() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerPhase.aggregate_into_accumulators_op)
  return _internal_aggregate_into_accumulators_op();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ServerPhase::set_aggregate_into_accumulators_op(ArgT0&& arg0, ArgT... args) {

 _impl_.aggregate_into_accumulators_op_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.ServerPhase.aggregate_into_accumulators_op)
}
inline std::string* ServerPhase::mutable_aggregate_into_accumulators_op() {
  std::string* _s = _internal_mutable_aggregate_into_accumulators_op();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerPhase.aggregate_into_accumulators_op)
  return _s;
}
inline const std::string& ServerPhase::_internal_aggregate_into_accumulators_op() const {
  return _impl_.aggregate_into_accumulators_op_.Get();
}
inline void ServerPhase::_internal_set_aggregate_into_accumulators_op(const std::string& value) {

  _impl_.aggregate_into_accumulators_op_.Set(value, GetArenaForAllocation());
}
inline std::string* ServerPhase::_internal_mutable_aggregate_into_accumulators_op() {

  return _impl_.aggregate_into_accumulators_op_.Mutable(GetArenaForAllocation());
}
inline std::string* ServerPhase::release_aggregate_into_accumulators_op() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ServerPhase.aggregate_into_accumulators_op)
  return _impl_.aggregate_into_accumulators_op_.Release();
}
inline void ServerPhase::set_allocated_aggregate_into_accumulators_op(std::string* aggregate_into_accumulators_op) {
  _impl_.aggregate_into_accumulators_op_.SetAllocated(aggregate_into_accumulators_op, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.aggregate_into_accumulators_op_.IsDefault()) {
    _impl_.aggregate_into_accumulators_op_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ServerPhase.aggregate_into_accumulators_op)
}

// .google.internal.federated.plan.CheckpointOp read_aggregated_update = 10;
inline bool ServerPhase::_internal_has_read_aggregated_update() const {
  return this != internal_default_instance() && _impl_.read_aggregated_update_ != nullptr;
}
inline bool ServerPhase::has_read_aggregated_update() const {
  return _internal_has_read_aggregated_update();
}
inline void ServerPhase::clear_read_aggregated_update() {
  if (GetArenaForAllocation() == nullptr && _impl_.read_aggregated_update_ != nullptr) {
    delete _impl_.read_aggregated_update_;
  }
  _impl_.read_aggregated_update_ = nullptr;
}
inline const ::google::internal::federated::plan::CheckpointOp& ServerPhase::_internal_read_aggregated_update() const {
  const ::google::internal::federated::plan::CheckpointOp* p = _impl_.read_aggregated_update_;
  return p != nullptr ? *p : reinterpret_cast<const ::google::internal::federated::plan::CheckpointOp&>(
      ::google::internal::federated::plan::_CheckpointOp_default_instance_);
}
inline const ::google::internal::federated::plan::CheckpointOp& ServerPhase::read_aggregated_update() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerPhase.read_aggregated_update)
  return _internal_read_aggregated_update();
}
inline void ServerPhase::unsafe_arena_set_allocated_read_aggregated_update(
    ::google::internal::federated::plan::CheckpointOp* read_aggregated_update) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.read_aggregated_update_);
  }
  _impl_.read_aggregated_update_ = read_aggregated_update;
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.ServerPhase.read_aggregated_update)
}
inline ::google::internal::federated::plan::CheckpointOp* ServerPhase::release_read_aggregated_update() {

  ::google::internal::federated::plan::CheckpointOp* temp = _impl_.read_aggregated_update_;
  _impl_.read_aggregated_update_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::google::internal::federated::plan::CheckpointOp* ServerPhase::unsafe_arena_release_read_aggregated_update() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ServerPhase.read_aggregated_update)

  ::google::internal::federated::plan::CheckpointOp* temp = _impl_.read_aggregated_update_;
  _impl_.read_aggregated_update_ = nullptr;
  return temp;
}
inline ::google::internal::federated::plan::CheckpointOp* ServerPhase::_internal_mutable_read_aggregated_update() {

  if (_impl_.read_aggregated_update_ == nullptr) {
    auto* p = CreateMaybeMessage<::google::internal::federated::plan::CheckpointOp>(GetArenaForAllocation());
    _impl_.read_aggregated_update_ = p;
  }
  return _impl_.read_aggregated_update_;
}
inline ::google::internal::federated::plan::CheckpointOp* ServerPhase::mutable_read_aggregated_update() {
  ::google::internal::federated::plan::CheckpointOp* _msg = _internal_mutable_read_aggregated_update();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerPhase.read_aggregated_update)
  return _msg;
}
inline void ServerPhase::set_allocated_read_aggregated_update(::google::internal::federated::plan::CheckpointOp* read_aggregated_update) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.read_aggregated_update_;
  }
  if (read_aggregated_update) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(read_aggregated_update);
    if (message_arena != submessage_arena) {
      read_aggregated_update = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, read_aggregated_update, submessage_arena);
    }

  } else {

  }
  _impl_.read_aggregated_update_ = read_aggregated_update;
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ServerPhase.read_aggregated_update)
}

// .google.internal.federated.plan.CheckpointOp write_intermediate_update = 7;
inline bool ServerPhase::_internal_has_write_intermediate_update() const {
  return this != internal_default_instance() && _impl_.write_intermediate_update_ != nullptr;
}
inline bool ServerPhase::has_write_intermediate_update() const {
  return _internal_has_write_intermediate_update();
}
inline void ServerPhase::clear_write_intermediate_update() {
  if (GetArenaForAllocation() == nullptr && _impl_.write_intermediate_update_ != nullptr) {
    delete _impl_.write_intermediate_update_;
  }
  _impl_.write_intermediate_update_ = nullptr;
}
inline const ::google::internal::federated::plan::CheckpointOp& ServerPhase::_internal_write_intermediate_update() const {
  const ::google::internal::federated::plan::CheckpointOp* p = _impl_.write_intermediate_update_;
  return p != nullptr ? *p : reinterpret_cast<const ::google::internal::federated::plan::CheckpointOp&>(
      ::google::internal::federated::plan::_CheckpointOp_default_instance_);
}
inline const ::google::internal::federated::plan::CheckpointOp& ServerPhase::write_intermediate_update() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerPhase.write_intermediate_update)
  return _internal_write_intermediate_update();
}
inline void ServerPhase::unsafe_arena_set_allocated_write_intermediate_update(
    ::google::internal::federated::plan::CheckpointOp* write_intermediate_update) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.write_intermediate_update_);
  }
  _impl_.write_intermediate_update_ = write_intermediate_update;
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.ServerPhase.write_intermediate_update)
}
inline ::google::internal::federated::plan::CheckpointOp* ServerPhase::release_write_intermediate_update() {

  ::google::internal::federated::plan::CheckpointOp* temp = _impl_.write_intermediate_update_;
  _impl_.write_intermediate_update_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::google::internal::federated::plan::CheckpointOp* ServerPhase::unsafe_arena_release_write_intermediate_update() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ServerPhase.write_intermediate_update)

  ::google::internal::federated::plan::CheckpointOp* temp = _impl_.write_intermediate_update_;
  _impl_.write_intermediate_update_ = nullptr;
  return temp;
}
inline ::google::internal::federated::plan::CheckpointOp* ServerPhase::_internal_mutable_write_intermediate_update() {

  if (_impl_.write_intermediate_update_ == nullptr) {
    auto* p = CreateMaybeMessage<::google::internal::federated::plan::CheckpointOp>(GetArenaForAllocation());
    _impl_.write_intermediate_update_ = p;
  }
  return _impl_.write_intermediate_update_;
}
inline ::google::internal::federated::plan::CheckpointOp* ServerPhase::mutable_write_intermediate_update() {
  ::google::internal::federated::plan::CheckpointOp* _msg = _internal_mutable_write_intermediate_update();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerPhase.write_intermediate_update)
  return _msg;
}
inline void ServerPhase::set_allocated_write_intermediate_update(::google::internal::federated::plan::CheckpointOp* write_intermediate_update) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.write_intermediate_update_;
  }
  if (write_intermediate_update) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(write_intermediate_update);
    if (message_arena != submessage_arena) {
      write_intermediate_update = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, write_intermediate_update, submessage_arena);
    }

  } else {

  }
  _impl_.write_intermediate_update_ = write_intermediate_update;
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ServerPhase.write_intermediate_update)
}

// .google.internal.federated.plan.CheckpointOp write_client_init = 2;
inline bool ServerPhase::_internal_has_write_client_init() const {
  return this != internal_default_instance() && _impl_.write_client_init_ != nullptr;
}
inline bool ServerPhase::has_write_client_init() const {
  return _internal_has_write_client_init();
}
inline void ServerPhase::clear_write_client_init() {
  if (GetArenaForAllocation() == nullptr && _impl_.write_client_init_ != nullptr) {
    delete _impl_.write_client_init_;
  }
  _impl_.write_client_init_ = nullptr;
}
inline const ::google::internal::federated::plan::CheckpointOp& ServerPhase::_internal_write_client_init() const {
  const ::google::internal::federated::plan::CheckpointOp* p = _impl_.write_client_init_;
  return p != nullptr ? *p : reinterpret_cast<const ::google::internal::federated::plan::CheckpointOp&>(
      ::google::internal::federated::plan::_CheckpointOp_default_instance_);
}
inline const ::google::internal::federated::plan::CheckpointOp& ServerPhase::write_client_init() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerPhase.write_client_init)
  return _internal_write_client_init();
}
inline void ServerPhase::unsafe_arena_set_allocated_write_client_init(
    ::google::internal::federated::plan::CheckpointOp* write_client_init) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.write_client_init_);
  }
  _impl_.write_client_init_ = write_client_init;
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.ServerPhase.write_client_init)
}
inline ::google::internal::federated::plan::CheckpointOp* ServerPhase::release_write_client_init() {

  ::google::internal::federated::plan::CheckpointOp* temp = _impl_.write_client_init_;
  _impl_.write_client_init_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::google::internal::federated::plan::CheckpointOp* ServerPhase::unsafe_arena_release_write_client_init() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ServerPhase.write_client_init)

  ::google::internal::federated::plan::CheckpointOp* temp = _impl_.write_client_init_;
  _impl_.write_client_init_ = nullptr;
  return temp;
}
inline ::google::internal::federated::plan::CheckpointOp* ServerPhase::_internal_mutable_write_client_init() {

  if (_impl_.write_client_init_ == nullptr) {
    auto* p = CreateMaybeMessage<::google::internal::federated::plan::CheckpointOp>(GetArenaForAllocation());
    _impl_.write_client_init_ = p;
  }
  return _impl_.write_client_init_;
}
inline ::google::internal::federated::plan::CheckpointOp* ServerPhase::mutable_write_client_init() {
  ::google::internal::federated::plan::CheckpointOp* _msg = _internal_mutable_write_client_init();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerPhase.write_client_init)
  return _msg;
}
inline void ServerPhase::set_allocated_write_client_init(::google::internal::federated::plan::CheckpointOp* write_client_init) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.write_client_init_;
  }
  if (write_client_init) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(write_client_init);
    if (message_arena != submessage_arena) {
      write_client_init = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, write_client_init, submessage_arena);
    }

  } else {

  }
  _impl_.write_client_init_ = write_client_init;
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ServerPhase.write_client_init)
}

// .google.internal.federated.plan.CheckpointOp read_intermediate_update = 9;
inline bool ServerPhase::_internal_has_read_intermediate_update() const {
  return this != internal_default_instance() && _impl_.read_intermediate_update_ != nullptr;
}
inline bool ServerPhase::has_read_intermediate_update() const {
  return _internal_has_read_intermediate_update();
}
inline void ServerPhase::clear_read_intermediate_update() {
  if (GetArenaForAllocation() == nullptr && _impl_.read_intermediate_update_ != nullptr) {
    delete _impl_.read_intermediate_update_;
  }
  _impl_.read_intermediate_update_ = nullptr;
}
inline const ::google::internal::federated::plan::CheckpointOp& ServerPhase::_internal_read_intermediate_update() const {
  const ::google::internal::federated::plan::CheckpointOp* p = _impl_.read_intermediate_update_;
  return p != nullptr ? *p : reinterpret_cast<const ::google::internal::federated::plan::CheckpointOp&>(
      ::google::internal::federated::plan::_CheckpointOp_default_instance_);
}
inline const ::google::internal::federated::plan::CheckpointOp& ServerPhase::read_intermediate_update() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerPhase.read_intermediate_update)
  return _internal_read_intermediate_update();
}
inline void ServerPhase::unsafe_arena_set_allocated_read_intermediate_update(
    ::google::internal::federated::plan::CheckpointOp* read_intermediate_update) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.read_intermediate_update_);
  }
  _impl_.read_intermediate_update_ = read_intermediate_update;
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.ServerPhase.read_intermediate_update)
}
inline ::google::internal::federated::plan::CheckpointOp* ServerPhase::release_read_intermediate_update() {

  ::google::internal::federated::plan::CheckpointOp* temp = _impl_.read_intermediate_update_;
  _impl_.read_intermediate_update_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::google::internal::federated::plan::CheckpointOp* ServerPhase::unsafe_arena_release_read_intermediate_update() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ServerPhase.read_intermediate_update)

  ::google::internal::federated::plan::CheckpointOp* temp = _impl_.read_intermediate_update_;
  _impl_.read_intermediate_update_ = nullptr;
  return temp;
}
inline ::google::internal::federated::plan::CheckpointOp* ServerPhase::_internal_mutable_read_intermediate_update() {

  if (_impl_.read_intermediate_update_ == nullptr) {
    auto* p = CreateMaybeMessage<::google::internal::federated::plan::CheckpointOp>(GetArenaForAllocation());
    _impl_.read_intermediate_update_ = p;
  }
  return _impl_.read_intermediate_update_;
}
inline ::google::internal::federated::plan::CheckpointOp* ServerPhase::mutable_read_intermediate_update() {
  ::google::internal::federated::plan::CheckpointOp* _msg = _internal_mutable_read_intermediate_update();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerPhase.read_intermediate_update)
  return _msg;
}
inline void ServerPhase::set_allocated_read_intermediate_update(::google::internal::federated::plan::CheckpointOp* read_intermediate_update) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.read_intermediate_update_;
  }
  if (read_intermediate_update) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(read_intermediate_update);
    if (message_arena != submessage_arena) {
      read_intermediate_update = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, read_intermediate_update, submessage_arena);
    }

  } else {

  }
  _impl_.read_intermediate_update_ = read_intermediate_update;
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ServerPhase.read_intermediate_update)
}

// string intermediate_aggregate_into_accumulators_op = 11;
inline void ServerPhase::clear_intermediate_aggregate_into_accumulators_op() {
  _impl_.intermediate_aggregate_into_accumulators_op_.ClearToEmpty();
}
inline const std::string& ServerPhase::intermediate_aggregate_into_accumulators_op() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerPhase.intermediate_aggregate_into_accumulators_op)
  return _internal_intermediate_aggregate_into_accumulators_op();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ServerPhase::set_intermediate_aggregate_into_accumulators_op(ArgT0&& arg0, ArgT... args) {

 _impl_.intermediate_aggregate_into_accumulators_op_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.ServerPhase.intermediate_aggregate_into_accumulators_op)
}
inline std::string* ServerPhase::mutable_intermediate_aggregate_into_accumulators_op() {
  std::string* _s = _internal_mutable_intermediate_aggregate_into_accumulators_op();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerPhase.intermediate_aggregate_into_accumulators_op)
  return _s;
}
inline const std::string& ServerPhase::_internal_intermediate_aggregate_into_accumulators_op() const {
  return _impl_.intermediate_aggregate_into_accumulators_op_.Get();
}
inline void ServerPhase::_internal_set_intermediate_aggregate_into_accumulators_op(const std::string& value) {

  _impl_.intermediate_aggregate_into_accumulators_op_.Set(value, GetArenaForAllocation());
}
inline std::string* ServerPhase::_internal_mutable_intermediate_aggregate_into_accumulators_op() {

  return _impl_.intermediate_aggregate_into_accumulators_op_.Mutable(GetArenaForAllocation());
}
inline std::string* ServerPhase::release_intermediate_aggregate_into_accumulators_op() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ServerPhase.intermediate_aggregate_into_accumulators_op)
  return _impl_.intermediate_aggregate_into_accumulators_op_.Release();
}
inline void ServerPhase::set_allocated_intermediate_aggregate_into_accumulators_op(std::string* intermediate_aggregate_into_accumulators_op) {
  _impl_.intermediate_aggregate_into_accumulators_op_.SetAllocated(intermediate_aggregate_into_accumulators_op, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.intermediate_aggregate_into_accumulators_op_.IsDefault()) {
    _impl_.intermediate_aggregate_into_accumulators_op_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ServerPhase.intermediate_aggregate_into_accumulators_op)
}

// .google.internal.federated.plan.CheckpointOp write_accumulators = 12;
inline bool ServerPhase::_internal_has_write_accumulators() const {
  return this != internal_default_instance() && _impl_.write_accumulators_ != nullptr;
}
inline bool ServerPhase::has_write_accumulators() const {
  return _internal_has_write_accumulators();
}
inline void ServerPhase::clear_write_accumulators() {
  if (GetArenaForAllocation() == nullptr && _impl_.write_accumulators_ != nullptr) {
    delete _impl_.write_accumulators_;
  }
  _impl_.write_accumulators_ = nullptr;
}
inline const ::google::internal::federated::plan::CheckpointOp& ServerPhase::_internal_write_accumulators() const {
  const ::google::internal::federated::plan::CheckpointOp* p = _impl_.write_accumulators_;
  return p != nullptr ? *p : reinterpret_cast<const ::google::internal::federated::plan::CheckpointOp&>(
      ::google::internal::federated::plan::_CheckpointOp_default_instance_);
}
inline const ::google::internal::federated::plan::CheckpointOp& ServerPhase::write_accumulators() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerPhase.write_accumulators)
  return _internal_write_accumulators();
}
inline void ServerPhase::unsafe_arena_set_allocated_write_accumulators(
    ::google::internal::federated::plan::CheckpointOp* write_accumulators) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.write_accumulators_);
  }
  _impl_.write_accumulators_ = write_accumulators;
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.ServerPhase.write_accumulators)
}
inline ::google::internal::federated::plan::CheckpointOp* ServerPhase::release_write_accumulators() {

  ::google::internal::federated::plan::CheckpointOp* temp = _impl_.write_accumulators_;
  _impl_.write_accumulators_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::google::internal::federated::plan::CheckpointOp* ServerPhase::unsafe_arena_release_write_accumulators() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ServerPhase.write_accumulators)

  ::google::internal::federated::plan::CheckpointOp* temp = _impl_.write_accumulators_;
  _impl_.write_accumulators_ = nullptr;
  return temp;
}
inline ::google::internal::federated::plan::CheckpointOp* ServerPhase::_internal_mutable_write_accumulators() {

  if (_impl_.write_accumulators_ == nullptr) {
    auto* p = CreateMaybeMessage<::google::internal::federated::plan::CheckpointOp>(GetArenaForAllocation());
    _impl_.write_accumulators_ = p;
  }
  return _impl_.write_accumulators_;
}
inline ::google::internal::federated::plan::CheckpointOp* ServerPhase::mutable_write_accumulators() {
  ::google::internal::federated::plan::CheckpointOp* _msg = _internal_mutable_write_accumulators();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerPhase.write_accumulators)
  return _msg;
}
inline void ServerPhase::set_allocated_write_accumulators(::google::internal::federated::plan::CheckpointOp* write_accumulators) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.write_accumulators_;
  }
  if (write_accumulators) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(write_accumulators);
    if (message_arena != submessage_arena) {
      write_accumulators = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, write_accumulators, submessage_arena);
    }

  } else {

  }
  _impl_.write_accumulators_ = write_accumulators;
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ServerPhase.write_accumulators)
}

// string apply_aggregrated_updates_op = 5;
inline void ServerPhase::clear_apply_aggregrated_updates_op() {
  _impl_.apply_aggregrated_updates_op_.ClearToEmpty();
}
inline const std::string& ServerPhase::apply_aggregrated_updates_op() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerPhase.apply_aggregrated_updates_op)
  return _internal_apply_aggregrated_updates_op();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ServerPhase::set_apply_aggregrated_updates_op(ArgT0&& arg0, ArgT... args) {

 _impl_.apply_aggregrated_updates_op_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.ServerPhase.apply_aggregrated_updates_op)
}
inline std::string* ServerPhase::mutable_apply_aggregrated_updates_op() {
  std::string* _s = _internal_mutable_apply_aggregrated_updates_op();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerPhase.apply_aggregrated_updates_op)
  return _s;
}
inline const std::string& ServerPhase::_internal_apply_aggregrated_updates_op() const {
  return _impl_.apply_aggregrated_updates_op_.Get();
}
inline void ServerPhase::_internal_set_apply_aggregrated_updates_op(const std::string& value) {

  _impl_.apply_aggregrated_updates_op_.Set(value, GetArenaForAllocation());
}
inline std::string* ServerPhase::_internal_mutable_apply_aggregrated_updates_op() {

  return _impl_.apply_aggregrated_updates_op_.Mutable(GetArenaForAllocation());
}
inline std::string* ServerPhase::release_apply_aggregrated_updates_op() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ServerPhase.apply_aggregrated_updates_op)
  return _impl_.apply_aggregrated_updates_op_.Release();
}
inline void ServerPhase::set_allocated_apply_aggregrated_updates_op(std::string* apply_aggregrated_updates_op) {
  _impl_.apply_aggregrated_updates_op_.SetAllocated(apply_aggregrated_updates_op, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.apply_aggregrated_updates_op_.IsDefault()) {
    _impl_.apply_aggregrated_updates_op_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ServerPhase.apply_aggregrated_updates_op)
}

// repeated .google.internal.federated.plan.Metric metrics = 6;
inline int ServerPhase::_internal_metrics_size() const {
  return _impl_.metrics_.size();
}
inline int ServerPhase::metrics_size() const {
  return _internal_metrics_size();
}
inline void ServerPhase::clear_metrics() {
  _impl_.metrics_.Clear();
}
inline ::google::internal::federated::plan::Metric* ServerPhase::mutable_metrics(int index) {
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerPhase.metrics)
  return _impl_.metrics_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::Metric >*
ServerPhase::mutable_metrics() {
  // @@protoc_insertion_point(field_mutable_list:google.internal.federated.plan.ServerPhase.metrics)
  return &_impl_.metrics_;
}
inline const ::google::internal::federated::plan::Metric& ServerPhase::_internal_metrics(int index) const {
  return _impl_.metrics_.Get(index);
}
inline const ::google::internal::federated::plan::Metric& ServerPhase::metrics(int index) const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerPhase.metrics)
  return _internal_metrics(index);
}
inline ::google::internal::federated::plan::Metric* ServerPhase::_internal_add_metrics() {
  return _impl_.metrics_.Add();
}
inline ::google::internal::federated::plan::Metric* ServerPhase::add_metrics() {
  ::google::internal::federated::plan::Metric* _add = _internal_add_metrics();
  // @@protoc_insertion_point(field_add:google.internal.federated.plan.ServerPhase.metrics)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::Metric >&
ServerPhase::metrics() const {
  // @@protoc_insertion_point(field_list:google.internal.federated.plan.ServerPhase.metrics)
  return _impl_.metrics_;
}

// -------------------------------------------------------------------

// ServerEligibilityComputationPhase

// string name = 1;
inline void ServerEligibilityComputationPhase::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& ServerEligibilityComputationPhase::name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerEligibilityComputationPhase.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ServerEligibilityComputationPhase::set_name(ArgT0&& arg0, ArgT... args) {

 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.ServerEligibilityComputationPhase.name)
}
inline std::string* ServerEligibilityComputationPhase::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerEligibilityComputationPhase.name)
  return _s;
}
inline const std::string& ServerEligibilityComputationPhase::_internal_name() const {
  return _impl_.name_.Get();
}
inline void ServerEligibilityComputationPhase::_internal_set_name(const std::string& value) {

  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* ServerEligibilityComputationPhase::_internal_mutable_name() {

  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* ServerEligibilityComputationPhase::release_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ServerEligibilityComputationPhase.name)
  return _impl_.name_.Release();
}
inline void ServerEligibilityComputationPhase::set_allocated_name(std::string* name) {
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ServerEligibilityComputationPhase.name)
}

// repeated string target_node_names = 2;
inline int ServerEligibilityComputationPhase::_internal_target_node_names_size() const {
  return _impl_.target_node_names_.size();
}
inline int ServerEligibilityComputationPhase::target_node_names_size() const {
  return _internal_target_node_names_size();
}
inline void ServerEligibilityComputationPhase::clear_target_node_names() {
  _impl_.target_node_names_.Clear();
}
inline std::string* ServerEligibilityComputationPhase::add_target_node_names() {
  std::string* _s = _internal_add_target_node_names();
  // @@protoc_insertion_point(field_add_mutable:google.internal.federated.plan.ServerEligibilityComputationPhase.target_node_names)
  return _s;
}
inline const std::string& ServerEligibilityComputationPhase::_internal_target_node_names(int index) const {
  return _impl_.target_node_names_.Get(index);
}
inline const std::string& ServerEligibilityComputationPhase::target_node_names(int index) const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerEligibilityComputationPhase.target_node_names)
  return _internal_target_node_names(index);
}
inline std::string* ServerEligibilityComputationPhase::mutable_target_node_names(int index) {
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerEligibilityComputationPhase.target_node_names)
  return _impl_.target_node_names_.Mutable(index);
}
inline void ServerEligibilityComputationPhase::set_target_node_names(int index, const std::string& value) {
  _impl_.target_node_names_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.ServerEligibilityComputationPhase.target_node_names)
}
inline void ServerEligibilityComputationPhase::set_target_node_names(int index, std::string&& value) {
  _impl_.target_node_names_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.ServerEligibilityComputationPhase.target_node_names)
}
inline void ServerEligibilityComputationPhase::set_target_node_names(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.target_node_names_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:google.internal.federated.plan.ServerEligibilityComputationPhase.target_node_names)
}
inline void ServerEligibilityComputationPhase::set_target_node_names(int index, const char* value, size_t size) {
  _impl_.target_node_names_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:google.internal.federated.plan.ServerEligibilityComputationPhase.target_node_names)
}
inline std::string* ServerEligibilityComputationPhase::_internal_add_target_node_names() {
  return _impl_.target_node_names_.Add();
}
inline void ServerEligibilityComputationPhase::add_target_node_names(const std::string& value) {
  _impl_.target_node_names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:google.internal.federated.plan.ServerEligibilityComputationPhase.target_node_names)
}
inline void ServerEligibilityComputationPhase::add_target_node_names(std::string&& value) {
  _impl_.target_node_names_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:google.internal.federated.plan.ServerEligibilityComputationPhase.target_node_names)
}
inline void ServerEligibilityComputationPhase::add_target_node_names(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.target_node_names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:google.internal.federated.plan.ServerEligibilityComputationPhase.target_node_names)
}
inline void ServerEligibilityComputationPhase::add_target_node_names(const char* value, size_t size) {
  _impl_.target_node_names_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:google.internal.federated.plan.ServerEligibilityComputationPhase.target_node_names)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
ServerEligibilityComputationPhase::target_node_names() const {
  // @@protoc_insertion_point(field_list:google.internal.federated.plan.ServerEligibilityComputationPhase.target_node_names)
  return _impl_.target_node_names_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
ServerEligibilityComputationPhase::mutable_target_node_names() {
  // @@protoc_insertion_point(field_mutable_list:google.internal.federated.plan.ServerEligibilityComputationPhase.target_node_names)
  return &_impl_.target_node_names_;
}

// .google.internal.federated.plan.TEContextServerEligibilityIORouter task_eligibility = 3 [lazy = true];
inline bool ServerEligibilityComputationPhase::_internal_has_task_eligibility() const {
  return server_eligibility_io_router_case() == kTaskEligibility;
}
inline bool ServerEligibilityComputationPhase::has_task_eligibility() const {
  return _internal_has_task_eligibility();
}
inline void ServerEligibilityComputationPhase::set_has_task_eligibility() {
  _impl_._oneof_case_[0] = kTaskEligibility;
}
inline void ServerEligibilityComputationPhase::clear_task_eligibility() {
  if (_internal_has_task_eligibility()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.server_eligibility_io_router_.task_eligibility_;
    }
    clear_has_server_eligibility_io_router();
  }
}
inline ::google::internal::federated::plan::TEContextServerEligibilityIORouter* ServerEligibilityComputationPhase::release_task_eligibility() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ServerEligibilityComputationPhase.task_eligibility)
  if (_internal_has_task_eligibility()) {
    clear_has_server_eligibility_io_router();
    ::google::internal::federated::plan::TEContextServerEligibilityIORouter* temp = _impl_.server_eligibility_io_router_.task_eligibility_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.server_eligibility_io_router_.task_eligibility_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::google::internal::federated::plan::TEContextServerEligibilityIORouter& ServerEligibilityComputationPhase::_internal_task_eligibility() const {
  return _internal_has_task_eligibility()
      ? *_impl_.server_eligibility_io_router_.task_eligibility_
      : reinterpret_cast< ::google::internal::federated::plan::TEContextServerEligibilityIORouter&>(::google::internal::federated::plan::_TEContextServerEligibilityIORouter_default_instance_);
}
inline const ::google::internal::federated::plan::TEContextServerEligibilityIORouter& ServerEligibilityComputationPhase::task_eligibility() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ServerEligibilityComputationPhase.task_eligibility)
  return _internal_task_eligibility();
}
inline ::google::internal::federated::plan::TEContextServerEligibilityIORouter* ServerEligibilityComputationPhase::unsafe_arena_release_task_eligibility() {
  // @@protoc_insertion_point(field_unsafe_arena_release:google.internal.federated.plan.ServerEligibilityComputationPhase.task_eligibility)
  if (_internal_has_task_eligibility()) {
    clear_has_server_eligibility_io_router();
    ::google::internal::federated::plan::TEContextServerEligibilityIORouter* temp = _impl_.server_eligibility_io_router_.task_eligibility_;
    _impl_.server_eligibility_io_router_.task_eligibility_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ServerEligibilityComputationPhase::unsafe_arena_set_allocated_task_eligibility(::google::internal::federated::plan::TEContextServerEligibilityIORouter* task_eligibility) {
  clear_server_eligibility_io_router();
  if (task_eligibility) {
    set_has_task_eligibility();
    _impl_.server_eligibility_io_router_.task_eligibility_ = task_eligibility;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.ServerEligibilityComputationPhase.task_eligibility)
}
inline ::google::internal::federated::plan::TEContextServerEligibilityIORouter* ServerEligibilityComputationPhase::_internal_mutable_task_eligibility() {
  if (!_internal_has_task_eligibility()) {
    clear_server_eligibility_io_router();
    set_has_task_eligibility();
    _impl_.server_eligibility_io_router_.task_eligibility_ = CreateMaybeMessage< ::google::internal::federated::plan::TEContextServerEligibilityIORouter >(GetArenaForAllocation());
  }
  return _impl_.server_eligibility_io_router_.task_eligibility_;
}
inline ::google::internal::federated::plan::TEContextServerEligibilityIORouter* ServerEligibilityComputationPhase::mutable_task_eligibility() {
  ::google::internal::federated::plan::TEContextServerEligibilityIORouter* _msg = _internal_mutable_task_eligibility();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ServerEligibilityComputationPhase.task_eligibility)
  return _msg;
}

inline bool ServerEligibilityComputationPhase::has_server_eligibility_io_router() const {
  return server_eligibility_io_router_case() != SERVER_ELIGIBILITY_IO_ROUTER_NOT_SET;
}
inline void ServerEligibilityComputationPhase::clear_has_server_eligibility_io_router() {
  _impl_._oneof_case_[0] = SERVER_ELIGIBILITY_IO_ROUTER_NOT_SET;
}
inline ServerEligibilityComputationPhase::ServerEligibilityIoRouterCase ServerEligibilityComputationPhase::server_eligibility_io_router_case() const {
  return ServerEligibilityComputationPhase::ServerEligibilityIoRouterCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// TEContextServerEligibilityIORouter

// string context_proto_input_tensor_name = 1;
inline void TEContextServerEligibilityIORouter::clear_context_proto_input_tensor_name() {
  _impl_.context_proto_input_tensor_name_.ClearToEmpty();
}
inline const std::string& TEContextServerEligibilityIORouter::context_proto_input_tensor_name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.TEContextServerEligibilityIORouter.context_proto_input_tensor_name)
  return _internal_context_proto_input_tensor_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void TEContextServerEligibilityIORouter::set_context_proto_input_tensor_name(ArgT0&& arg0, ArgT... args) {

 _impl_.context_proto_input_tensor_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.TEContextServerEligibilityIORouter.context_proto_input_tensor_name)
}
inline std::string* TEContextServerEligibilityIORouter::mutable_context_proto_input_tensor_name() {
  std::string* _s = _internal_mutable_context_proto_input_tensor_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.TEContextServerEligibilityIORouter.context_proto_input_tensor_name)
  return _s;
}
inline const std::string& TEContextServerEligibilityIORouter::_internal_context_proto_input_tensor_name() const {
  return _impl_.context_proto_input_tensor_name_.Get();
}
inline void TEContextServerEligibilityIORouter::_internal_set_context_proto_input_tensor_name(const std::string& value) {

  _impl_.context_proto_input_tensor_name_.Set(value, GetArenaForAllocation());
}
inline std::string* TEContextServerEligibilityIORouter::_internal_mutable_context_proto_input_tensor_name() {

  return _impl_.context_proto_input_tensor_name_.Mutable(GetArenaForAllocation());
}
inline std::string* TEContextServerEligibilityIORouter::release_context_proto_input_tensor_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.TEContextServerEligibilityIORouter.context_proto_input_tensor_name)
  return _impl_.context_proto_input_tensor_name_.Release();
}
inline void TEContextServerEligibilityIORouter::set_allocated_context_proto_input_tensor_name(std::string* context_proto_input_tensor_name) {
  _impl_.context_proto_input_tensor_name_.SetAllocated(context_proto_input_tensor_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.context_proto_input_tensor_name_.IsDefault()) {
    _impl_.context_proto_input_tensor_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.TEContextServerEligibilityIORouter.context_proto_input_tensor_name)
}

// string output_filepath_tensor_name = 2;
inline void TEContextServerEligibilityIORouter::clear_output_filepath_tensor_name() {
  _impl_.output_filepath_tensor_name_.ClearToEmpty();
}
inline const std::string& TEContextServerEligibilityIORouter::output_filepath_tensor_name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.TEContextServerEligibilityIORouter.output_filepath_tensor_name)
  return _internal_output_filepath_tensor_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void TEContextServerEligibilityIORouter::set_output_filepath_tensor_name(ArgT0&& arg0, ArgT... args) {

 _impl_.output_filepath_tensor_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.TEContextServerEligibilityIORouter.output_filepath_tensor_name)
}
inline std::string* TEContextServerEligibilityIORouter::mutable_output_filepath_tensor_name() {
  std::string* _s = _internal_mutable_output_filepath_tensor_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.TEContextServerEligibilityIORouter.output_filepath_tensor_name)
  return _s;
}
inline const std::string& TEContextServerEligibilityIORouter::_internal_output_filepath_tensor_name() const {
  return _impl_.output_filepath_tensor_name_.Get();
}
inline void TEContextServerEligibilityIORouter::_internal_set_output_filepath_tensor_name(const std::string& value) {

  _impl_.output_filepath_tensor_name_.Set(value, GetArenaForAllocation());
}
inline std::string* TEContextServerEligibilityIORouter::_internal_mutable_output_filepath_tensor_name() {

  return _impl_.output_filepath_tensor_name_.Mutable(GetArenaForAllocation());
}
inline std::string* TEContextServerEligibilityIORouter::release_output_filepath_tensor_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.TEContextServerEligibilityIORouter.output_filepath_tensor_name)
  return _impl_.output_filepath_tensor_name_.Release();
}
inline void TEContextServerEligibilityIORouter::set_allocated_output_filepath_tensor_name(std::string* output_filepath_tensor_name) {
  _impl_.output_filepath_tensor_name_.SetAllocated(output_filepath_tensor_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.output_filepath_tensor_name_.IsDefault()) {
    _impl_.output_filepath_tensor_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.TEContextServerEligibilityIORouter.output_filepath_tensor_name)
}

// -------------------------------------------------------------------

// Plan_Phase

// .google.internal.federated.plan.ClientPhase client_phase = 1;
inline bool Plan_Phase::_internal_has_client_phase() const {
  return this != internal_default_instance() && _impl_.client_phase_ != nullptr;
}
inline bool Plan_Phase::has_client_phase() const {
  return _internal_has_client_phase();
}
inline void Plan_Phase::clear_client_phase() {
  if (GetArenaForAllocation() == nullptr && _impl_.client_phase_ != nullptr) {
    delete _impl_.client_phase_;
  }
  _impl_.client_phase_ = nullptr;
}
inline const ::google::internal::federated::plan::ClientPhase& Plan_Phase::_internal_client_phase() const {
  const ::google::internal::federated::plan::ClientPhase* p = _impl_.client_phase_;
  return p != nullptr ? *p : reinterpret_cast<const ::google::internal::federated::plan::ClientPhase&>(
      ::google::internal::federated::plan::_ClientPhase_default_instance_);
}
inline const ::google::internal::federated::plan::ClientPhase& Plan_Phase::client_phase() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.Plan.Phase.client_phase)
  return _internal_client_phase();
}
inline void Plan_Phase::unsafe_arena_set_allocated_client_phase(
    ::google::internal::federated::plan::ClientPhase* client_phase) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.client_phase_);
  }
  _impl_.client_phase_ = client_phase;
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.Plan.Phase.client_phase)
}
inline ::google::internal::federated::plan::ClientPhase* Plan_Phase::release_client_phase() {

  ::google::internal::federated::plan::ClientPhase* temp = _impl_.client_phase_;
  _impl_.client_phase_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::google::internal::federated::plan::ClientPhase* Plan_Phase::unsafe_arena_release_client_phase() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.Plan.Phase.client_phase)

  ::google::internal::federated::plan::ClientPhase* temp = _impl_.client_phase_;
  _impl_.client_phase_ = nullptr;
  return temp;
}
inline ::google::internal::federated::plan::ClientPhase* Plan_Phase::_internal_mutable_client_phase() {

  if (_impl_.client_phase_ == nullptr) {
    auto* p = CreateMaybeMessage<::google::internal::federated::plan::ClientPhase>(GetArenaForAllocation());
    _impl_.client_phase_ = p;
  }
  return _impl_.client_phase_;
}
inline ::google::internal::federated::plan::ClientPhase* Plan_Phase::mutable_client_phase() {
  ::google::internal::federated::plan::ClientPhase* _msg = _internal_mutable_client_phase();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.Plan.Phase.client_phase)
  return _msg;
}
inline void Plan_Phase::set_allocated_client_phase(::google::internal::federated::plan::ClientPhase* client_phase) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.client_phase_;
  }
  if (client_phase) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(client_phase);
    if (message_arena != submessage_arena) {
      client_phase = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, client_phase, submessage_arena);
    }

  } else {

  }
  _impl_.client_phase_ = client_phase;
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.Plan.Phase.client_phase)
}

// .google.internal.federated.plan.ServerPhase server_phase = 2;
inline bool Plan_Phase::_internal_has_server_phase() const {
  return this != internal_default_instance() && _impl_.server_phase_ != nullptr;
}
inline bool Plan_Phase::has_server_phase() const {
  return _internal_has_server_phase();
}
inline void Plan_Phase::clear_server_phase() {
  if (GetArenaForAllocation() == nullptr && _impl_.server_phase_ != nullptr) {
    delete _impl_.server_phase_;
  }
  _impl_.server_phase_ = nullptr;
}
inline const ::google::internal::federated::plan::ServerPhase& Plan_Phase::_internal_server_phase() const {
  const ::google::internal::federated::plan::ServerPhase* p = _impl_.server_phase_;
  return p != nullptr ? *p : reinterpret_cast<const ::google::internal::federated::plan::ServerPhase&>(
      ::google::internal::federated::plan::_ServerPhase_default_instance_);
}
inline const ::google::internal::federated::plan::ServerPhase& Plan_Phase::server_phase() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.Plan.Phase.server_phase)
  return _internal_server_phase();
}
inline void Plan_Phase::unsafe_arena_set_allocated_server_phase(
    ::google::internal::federated::plan::ServerPhase* server_phase) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.server_phase_);
  }
  _impl_.server_phase_ = server_phase;
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.Plan.Phase.server_phase)
}
inline ::google::internal::federated::plan::ServerPhase* Plan_Phase::release_server_phase() {

  ::google::internal::federated::plan::ServerPhase* temp = _impl_.server_phase_;
  _impl_.server_phase_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::google::internal::federated::plan::ServerPhase* Plan_Phase::unsafe_arena_release_server_phase() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.Plan.Phase.server_phase)

  ::google::internal::federated::plan::ServerPhase* temp = _impl_.server_phase_;
  _impl_.server_phase_ = nullptr;
  return temp;
}
inline ::google::internal::federated::plan::ServerPhase* Plan_Phase::_internal_mutable_server_phase() {

  if (_impl_.server_phase_ == nullptr) {
    auto* p = CreateMaybeMessage<::google::internal::federated::plan::ServerPhase>(GetArenaForAllocation());
    _impl_.server_phase_ = p;
  }
  return _impl_.server_phase_;
}
inline ::google::internal::federated::plan::ServerPhase* Plan_Phase::mutable_server_phase() {
  ::google::internal::federated::plan::ServerPhase* _msg = _internal_mutable_server_phase();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.Plan.Phase.server_phase)
  return _msg;
}
inline void Plan_Phase::set_allocated_server_phase(::google::internal::federated::plan::ServerPhase* server_phase) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.server_phase_;
  }
  if (server_phase) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(server_phase);
    if (message_arena != submessage_arena) {
      server_phase = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, server_phase, submessage_arena);
    }

  } else {

  }
  _impl_.server_phase_ = server_phase;
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.Plan.Phase.server_phase)
}

// .google.internal.federated.plan.ServerPhaseV2 server_phase_v2 = 4;
inline bool Plan_Phase::_internal_has_server_phase_v2() const {
  return this != internal_default_instance() && _impl_.server_phase_v2_ != nullptr;
}
inline bool Plan_Phase::has_server_phase_v2() const {
  return _internal_has_server_phase_v2();
}
inline void Plan_Phase::clear_server_phase_v2() {
  if (GetArenaForAllocation() == nullptr && _impl_.server_phase_v2_ != nullptr) {
    delete _impl_.server_phase_v2_;
  }
  _impl_.server_phase_v2_ = nullptr;
}
inline const ::google::internal::federated::plan::ServerPhaseV2& Plan_Phase::_internal_server_phase_v2() const {
  const ::google::internal::federated::plan::ServerPhaseV2* p = _impl_.server_phase_v2_;
  return p != nullptr ? *p : reinterpret_cast<const ::google::internal::federated::plan::ServerPhaseV2&>(
      ::google::internal::federated::plan::_ServerPhaseV2_default_instance_);
}
inline const ::google::internal::federated::plan::ServerPhaseV2& Plan_Phase::server_phase_v2() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.Plan.Phase.server_phase_v2)
  return _internal_server_phase_v2();
}
inline void Plan_Phase::unsafe_arena_set_allocated_server_phase_v2(
    ::google::internal::federated::plan::ServerPhaseV2* server_phase_v2) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.server_phase_v2_);
  }
  _impl_.server_phase_v2_ = server_phase_v2;
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.Plan.Phase.server_phase_v2)
}
inline ::google::internal::federated::plan::ServerPhaseV2* Plan_Phase::release_server_phase_v2() {

  ::google::internal::federated::plan::ServerPhaseV2* temp = _impl_.server_phase_v2_;
  _impl_.server_phase_v2_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::google::internal::federated::plan::ServerPhaseV2* Plan_Phase::unsafe_arena_release_server_phase_v2() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.Plan.Phase.server_phase_v2)

  ::google::internal::federated::plan::ServerPhaseV2* temp = _impl_.server_phase_v2_;
  _impl_.server_phase_v2_ = nullptr;
  return temp;
}
inline ::google::internal::federated::plan::ServerPhaseV2* Plan_Phase::_internal_mutable_server_phase_v2() {

  if (_impl_.server_phase_v2_ == nullptr) {
    auto* p = CreateMaybeMessage<::google::internal::federated::plan::ServerPhaseV2>(GetArenaForAllocation());
    _impl_.server_phase_v2_ = p;
  }
  return _impl_.server_phase_v2_;
}
inline ::google::internal::federated::plan::ServerPhaseV2* Plan_Phase::mutable_server_phase_v2() {
  ::google::internal::federated::plan::ServerPhaseV2* _msg = _internal_mutable_server_phase_v2();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.Plan.Phase.server_phase_v2)
  return _msg;
}
inline void Plan_Phase::set_allocated_server_phase_v2(::google::internal::federated::plan::ServerPhaseV2* server_phase_v2) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.server_phase_v2_;
  }
  if (server_phase_v2) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(server_phase_v2);
    if (message_arena != submessage_arena) {
      server_phase_v2 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, server_phase_v2, submessage_arena);
    }

  } else {

  }
  _impl_.server_phase_v2_ = server_phase_v2;
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.Plan.Phase.server_phase_v2)
}

// .google.internal.federated.plan.ServerEligibilityComputationPhase server_eligibility_phase = 3;
inline bool Plan_Phase::_internal_has_server_eligibility_phase() const {
  return this != internal_default_instance() && _impl_.server_eligibility_phase_ != nullptr;
}
inline bool Plan_Phase::has_server_eligibility_phase() const {
  return _internal_has_server_eligibility_phase();
}
inline void Plan_Phase::clear_server_eligibility_phase() {
  if (GetArenaForAllocation() == nullptr && _impl_.server_eligibility_phase_ != nullptr) {
    delete _impl_.server_eligibility_phase_;
  }
  _impl_.server_eligibility_phase_ = nullptr;
}
inline const ::google::internal::federated::plan::ServerEligibilityComputationPhase& Plan_Phase::_internal_server_eligibility_phase() const {
  const ::google::internal::federated::plan::ServerEligibilityComputationPhase* p = _impl_.server_eligibility_phase_;
  return p != nullptr ? *p : reinterpret_cast<const ::google::internal::federated::plan::ServerEligibilityComputationPhase&>(
      ::google::internal::federated::plan::_ServerEligibilityComputationPhase_default_instance_);
}
inline const ::google::internal::federated::plan::ServerEligibilityComputationPhase& Plan_Phase::server_eligibility_phase() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.Plan.Phase.server_eligibility_phase)
  return _internal_server_eligibility_phase();
}
inline void Plan_Phase::unsafe_arena_set_allocated_server_eligibility_phase(
    ::google::internal::federated::plan::ServerEligibilityComputationPhase* server_eligibility_phase) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.server_eligibility_phase_);
  }
  _impl_.server_eligibility_phase_ = server_eligibility_phase;
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.Plan.Phase.server_eligibility_phase)
}
inline ::google::internal::federated::plan::ServerEligibilityComputationPhase* Plan_Phase::release_server_eligibility_phase() {

  ::google::internal::federated::plan::ServerEligibilityComputationPhase* temp = _impl_.server_eligibility_phase_;
  _impl_.server_eligibility_phase_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::google::internal::federated::plan::ServerEligibilityComputationPhase* Plan_Phase::unsafe_arena_release_server_eligibility_phase() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.Plan.Phase.server_eligibility_phase)

  ::google::internal::federated::plan::ServerEligibilityComputationPhase* temp = _impl_.server_eligibility_phase_;
  _impl_.server_eligibility_phase_ = nullptr;
  return temp;
}
inline ::google::internal::federated::plan::ServerEligibilityComputationPhase* Plan_Phase::_internal_mutable_server_eligibility_phase() {

  if (_impl_.server_eligibility_phase_ == nullptr) {
    auto* p = CreateMaybeMessage<::google::internal::federated::plan::ServerEligibilityComputationPhase>(GetArenaForAllocation());
    _impl_.server_eligibility_phase_ = p;
  }
  return _impl_.server_eligibility_phase_;
}
inline ::google::internal::federated::plan::ServerEligibilityComputationPhase* Plan_Phase::mutable_server_eligibility_phase() {
  ::google::internal::federated::plan::ServerEligibilityComputationPhase* _msg = _internal_mutable_server_eligibility_phase();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.Plan.Phase.server_eligibility_phase)
  return _msg;
}
inline void Plan_Phase::set_allocated_server_eligibility_phase(::google::internal::federated::plan::ServerEligibilityComputationPhase* server_eligibility_phase) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.server_eligibility_phase_;
  }
  if (server_eligibility_phase) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(server_eligibility_phase);
    if (message_arena != submessage_arena) {
      server_eligibility_phase = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, server_eligibility_phase, submessage_arena);
    }

  } else {

  }
  _impl_.server_eligibility_phase_ = server_eligibility_phase;
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.Plan.Phase.server_eligibility_phase)
}

// -------------------------------------------------------------------

// Plan

// .google.protobuf.Any server_graph_bytes = 7;
inline bool Plan::_internal_has_server_graph_bytes() const {
  return this != internal_default_instance() && _impl_.server_graph_bytes_ != nullptr;
}
inline bool Plan::has_server_graph_bytes() const {
  return _internal_has_server_graph_bytes();
}
inline const ::PROTOBUF_NAMESPACE_ID::Any& Plan::_internal_server_graph_bytes() const {
  const ::PROTOBUF_NAMESPACE_ID::Any* p = _impl_.server_graph_bytes_;
  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Any&>(
      ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::Any& Plan::server_graph_bytes() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.Plan.server_graph_bytes)
  return _internal_server_graph_bytes();
}
inline void Plan::unsafe_arena_set_allocated_server_graph_bytes(
    ::PROTOBUF_NAMESPACE_ID::Any* server_graph_bytes) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.server_graph_bytes_);
  }
  _impl_.server_graph_bytes_ = server_graph_bytes;
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.Plan.server_graph_bytes)
}
inline ::PROTOBUF_NAMESPACE_ID::Any* Plan::release_server_graph_bytes() {

  ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.server_graph_bytes_;
  _impl_.server_graph_bytes_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* Plan::unsafe_arena_release_server_graph_bytes() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.Plan.server_graph_bytes)

  ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.server_graph_bytes_;
  _impl_.server_graph_bytes_ = nullptr;
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* Plan::_internal_mutable_server_graph_bytes() {

  if (_impl_.server_graph_bytes_ == nullptr) {
    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation());
    _impl_.server_graph_bytes_ = p;
  }
  return _impl_.server_graph_bytes_;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* Plan::mutable_server_graph_bytes() {
  ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_server_graph_bytes();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.Plan.server_graph_bytes)
  return _msg;
}
inline void Plan::set_allocated_server_graph_bytes(::PROTOBUF_NAMESPACE_ID::Any* server_graph_bytes) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.server_graph_bytes_);
  }
  if (server_graph_bytes) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(server_graph_bytes));
    if (message_arena != submessage_arena) {
      server_graph_bytes = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, server_graph_bytes, submessage_arena);
    }

  } else {

  }
  _impl_.server_graph_bytes_ = server_graph_bytes;
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.Plan.server_graph_bytes)
}

// .google.protobuf.Any server_graph_prepare_bytes = 13;
inline bool Plan::_internal_has_server_graph_prepare_bytes() const {
  return this != internal_default_instance() && _impl_.server_graph_prepare_bytes_ != nullptr;
}
inline bool Plan::has_server_graph_prepare_bytes() const {
  return _internal_has_server_graph_prepare_bytes();
}
inline const ::PROTOBUF_NAMESPACE_ID::Any& Plan::_internal_server_graph_prepare_bytes() const {
  const ::PROTOBUF_NAMESPACE_ID::Any* p = _impl_.server_graph_prepare_bytes_;
  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Any&>(
      ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::Any& Plan::server_graph_prepare_bytes() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.Plan.server_graph_prepare_bytes)
  return _internal_server_graph_prepare_bytes();
}
inline void Plan::unsafe_arena_set_allocated_server_graph_prepare_bytes(
    ::PROTOBUF_NAMESPACE_ID::Any* server_graph_prepare_bytes) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.server_graph_prepare_bytes_);
  }
  _impl_.server_graph_prepare_bytes_ = server_graph_prepare_bytes;
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.Plan.server_graph_prepare_bytes)
}
inline ::PROTOBUF_NAMESPACE_ID::Any* Plan::release_server_graph_prepare_bytes() {

  ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.server_graph_prepare_bytes_;
  _impl_.server_graph_prepare_bytes_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* Plan::unsafe_arena_release_server_graph_prepare_bytes() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.Plan.server_graph_prepare_bytes)

  ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.server_graph_prepare_bytes_;
  _impl_.server_graph_prepare_bytes_ = nullptr;
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* Plan::_internal_mutable_server_graph_prepare_bytes() {

  if (_impl_.server_graph_prepare_bytes_ == nullptr) {
    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation());
    _impl_.server_graph_prepare_bytes_ = p;
  }
  return _impl_.server_graph_prepare_bytes_;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* Plan::mutable_server_graph_prepare_bytes() {
  ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_server_graph_prepare_bytes();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.Plan.server_graph_prepare_bytes)
  return _msg;
}
inline void Plan::set_allocated_server_graph_prepare_bytes(::PROTOBUF_NAMESPACE_ID::Any* server_graph_prepare_bytes) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.server_graph_prepare_bytes_);
  }
  if (server_graph_prepare_bytes) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(server_graph_prepare_bytes));
    if (message_arena != submessage_arena) {
      server_graph_prepare_bytes = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, server_graph_prepare_bytes, submessage_arena);
    }

  } else {

  }
  _impl_.server_graph_prepare_bytes_ = server_graph_prepare_bytes;
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.Plan.server_graph_prepare_bytes)
}

// .google.protobuf.Any server_graph_result_bytes = 14;
inline bool Plan::_internal_has_server_graph_result_bytes() const {
  return this != internal_default_instance() && _impl_.server_graph_result_bytes_ != nullptr;
}
inline bool Plan::has_server_graph_result_bytes() const {
  return _internal_has_server_graph_result_bytes();
}
inline const ::PROTOBUF_NAMESPACE_ID::Any& Plan::_internal_server_graph_result_bytes() const {
  const ::PROTOBUF_NAMESPACE_ID::Any* p = _impl_.server_graph_result_bytes_;
  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Any&>(
      ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::Any& Plan::server_graph_result_bytes() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.Plan.server_graph_result_bytes)
  return _internal_server_graph_result_bytes();
}
inline void Plan::unsafe_arena_set_allocated_server_graph_result_bytes(
    ::PROTOBUF_NAMESPACE_ID::Any* server_graph_result_bytes) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.server_graph_result_bytes_);
  }
  _impl_.server_graph_result_bytes_ = server_graph_result_bytes;
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.Plan.server_graph_result_bytes)
}
inline ::PROTOBUF_NAMESPACE_ID::Any* Plan::release_server_graph_result_bytes() {

  ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.server_graph_result_bytes_;
  _impl_.server_graph_result_bytes_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* Plan::unsafe_arena_release_server_graph_result_bytes() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.Plan.server_graph_result_bytes)

  ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.server_graph_result_bytes_;
  _impl_.server_graph_result_bytes_ = nullptr;
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* Plan::_internal_mutable_server_graph_result_bytes() {

  if (_impl_.server_graph_result_bytes_ == nullptr) {
    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation());
    _impl_.server_graph_result_bytes_ = p;
  }
  return _impl_.server_graph_result_bytes_;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* Plan::mutable_server_graph_result_bytes() {
  ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_server_graph_result_bytes();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.Plan.server_graph_result_bytes)
  return _msg;
}
inline void Plan::set_allocated_server_graph_result_bytes(::PROTOBUF_NAMESPACE_ID::Any* server_graph_result_bytes) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.server_graph_result_bytes_);
  }
  if (server_graph_result_bytes) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(server_graph_result_bytes));
    if (message_arena != submessage_arena) {
      server_graph_result_bytes = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, server_graph_result_bytes, submessage_arena);
    }

  } else {

  }
  _impl_.server_graph_result_bytes_ = server_graph_result_bytes;
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.Plan.server_graph_result_bytes)
}

// .google.internal.federated.plan.CheckpointOp server_savepoint = 2;
inline bool Plan::_internal_has_server_savepoint() const {
  return this != internal_default_instance() && _impl_.server_savepoint_ != nullptr;
}
inline bool Plan::has_server_savepoint() const {
  return _internal_has_server_savepoint();
}
inline void Plan::clear_server_savepoint() {
  if (GetArenaForAllocation() == nullptr && _impl_.server_savepoint_ != nullptr) {
    delete _impl_.server_savepoint_;
  }
  _impl_.server_savepoint_ = nullptr;
}
inline const ::google::internal::federated::plan::CheckpointOp& Plan::_internal_server_savepoint() const {
  const ::google::internal::federated::plan::CheckpointOp* p = _impl_.server_savepoint_;
  return p != nullptr ? *p : reinterpret_cast<const ::google::internal::federated::plan::CheckpointOp&>(
      ::google::internal::federated::plan::_CheckpointOp_default_instance_);
}
inline const ::google::internal::federated::plan::CheckpointOp& Plan::server_savepoint() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.Plan.server_savepoint)
  return _internal_server_savepoint();
}
inline void Plan::unsafe_arena_set_allocated_server_savepoint(
    ::google::internal::federated::plan::CheckpointOp* server_savepoint) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.server_savepoint_);
  }
  _impl_.server_savepoint_ = server_savepoint;
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.Plan.server_savepoint)
}
inline ::google::internal::federated::plan::CheckpointOp* Plan::release_server_savepoint() {

  ::google::internal::federated::plan::CheckpointOp* temp = _impl_.server_savepoint_;
  _impl_.server_savepoint_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::google::internal::federated::plan::CheckpointOp* Plan::unsafe_arena_release_server_savepoint() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.Plan.server_savepoint)

  ::google::internal::federated::plan::CheckpointOp* temp = _impl_.server_savepoint_;
  _impl_.server_savepoint_ = nullptr;
  return temp;
}
inline ::google::internal::federated::plan::CheckpointOp* Plan::_internal_mutable_server_savepoint() {

  if (_impl_.server_savepoint_ == nullptr) {
    auto* p = CreateMaybeMessage<::google::internal::federated::plan::CheckpointOp>(GetArenaForAllocation());
    _impl_.server_savepoint_ = p;
  }
  return _impl_.server_savepoint_;
}
inline ::google::internal::federated::plan::CheckpointOp* Plan::mutable_server_savepoint() {
  ::google::internal::federated::plan::CheckpointOp* _msg = _internal_mutable_server_savepoint();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.Plan.server_savepoint)
  return _msg;
}
inline void Plan::set_allocated_server_savepoint(::google::internal::federated::plan::CheckpointOp* server_savepoint) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.server_savepoint_;
  }
  if (server_savepoint) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(server_savepoint);
    if (message_arena != submessage_arena) {
      server_savepoint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, server_savepoint, submessage_arena);
    }

  } else {

  }
  _impl_.server_savepoint_ = server_savepoint;
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.Plan.server_savepoint)
}

// .google.protobuf.Any client_graph_bytes = 8;
inline bool Plan::_internal_has_client_graph_bytes() const {
  return this != internal_default_instance() && _impl_.client_graph_bytes_ != nullptr;
}
inline bool Plan::has_client_graph_bytes() const {
  return _internal_has_client_graph_bytes();
}
inline const ::PROTOBUF_NAMESPACE_ID::Any& Plan::_internal_client_graph_bytes() const {
  const ::PROTOBUF_NAMESPACE_ID::Any* p = _impl_.client_graph_bytes_;
  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Any&>(
      ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::Any& Plan::client_graph_bytes() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.Plan.client_graph_bytes)
  return _internal_client_graph_bytes();
}
inline void Plan::unsafe_arena_set_allocated_client_graph_bytes(
    ::PROTOBUF_NAMESPACE_ID::Any* client_graph_bytes) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.client_graph_bytes_);
  }
  _impl_.client_graph_bytes_ = client_graph_bytes;
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.Plan.client_graph_bytes)
}
inline ::PROTOBUF_NAMESPACE_ID::Any* Plan::release_client_graph_bytes() {

  ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.client_graph_bytes_;
  _impl_.client_graph_bytes_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* Plan::unsafe_arena_release_client_graph_bytes() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.Plan.client_graph_bytes)

  ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.client_graph_bytes_;
  _impl_.client_graph_bytes_ = nullptr;
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* Plan::_internal_mutable_client_graph_bytes() {

  if (_impl_.client_graph_bytes_ == nullptr) {
    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation());
    _impl_.client_graph_bytes_ = p;
  }
  return _impl_.client_graph_bytes_;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* Plan::mutable_client_graph_bytes() {
  ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_client_graph_bytes();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.Plan.client_graph_bytes)
  return _msg;
}
inline void Plan::set_allocated_client_graph_bytes(::PROTOBUF_NAMESPACE_ID::Any* client_graph_bytes) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.client_graph_bytes_);
  }
  if (client_graph_bytes) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(client_graph_bytes));
    if (message_arena != submessage_arena) {
      client_graph_bytes = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, client_graph_bytes, submessage_arena);
    }

  } else {

  }
  _impl_.client_graph_bytes_ = client_graph_bytes;
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.Plan.client_graph_bytes)
}

// bytes client_tflite_graph_bytes = 12;
inline void Plan::clear_client_tflite_graph_bytes() {
  _impl_.client_tflite_graph_bytes_.ClearToEmpty();
}
inline const std::string& Plan::client_tflite_graph_bytes() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.Plan.client_tflite_graph_bytes)
  return _internal_client_tflite_graph_bytes();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Plan::set_client_tflite_graph_bytes(ArgT0&& arg0, ArgT... args) {

 _impl_.client_tflite_graph_bytes_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.Plan.client_tflite_graph_bytes)
}
inline std::string* Plan::mutable_client_tflite_graph_bytes() {
  std::string* _s = _internal_mutable_client_tflite_graph_bytes();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.Plan.client_tflite_graph_bytes)
  return _s;
}
inline const std::string& Plan::_internal_client_tflite_graph_bytes() const {
  return _impl_.client_tflite_graph_bytes_.Get();
}
inline void Plan::_internal_set_client_tflite_graph_bytes(const std::string& value) {

  _impl_.client_tflite_graph_bytes_.Set(value, GetArenaForAllocation());
}
inline std::string* Plan::_internal_mutable_client_tflite_graph_bytes() {

  return _impl_.client_tflite_graph_bytes_.Mutable(GetArenaForAllocation());
}
inline std::string* Plan::release_client_tflite_graph_bytes() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.Plan.client_tflite_graph_bytes)
  return _impl_.client_tflite_graph_bytes_.Release();
}
inline void Plan::set_allocated_client_tflite_graph_bytes(std::string* client_tflite_graph_bytes) {
  _impl_.client_tflite_graph_bytes_.SetAllocated(client_tflite_graph_bytes, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.client_tflite_graph_bytes_.IsDefault()) {
    _impl_.client_tflite_graph_bytes_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.Plan.client_tflite_graph_bytes)
}

// repeated .google.internal.federated.plan.Plan.Phase phase = 4;
inline int Plan::_internal_phase_size() const {
  return _impl_.phase_.size();
}
inline int Plan::phase_size() const {
  return _internal_phase_size();
}
inline void Plan::clear_phase() {
  _impl_.phase_.Clear();
}
inline ::google::internal::federated::plan::Plan_Phase* Plan::mutable_phase(int index) {
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.Plan.phase)
  return _impl_.phase_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::Plan_Phase >*
Plan::mutable_phase() {
  // @@protoc_insertion_point(field_mutable_list:google.internal.federated.plan.Plan.phase)
  return &_impl_.phase_;
}
inline const ::google::internal::federated::plan::Plan_Phase& Plan::_internal_phase(int index) const {
  return _impl_.phase_.Get(index);
}
inline const ::google::internal::federated::plan::Plan_Phase& Plan::phase(int index) const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.Plan.phase)
  return _internal_phase(index);
}
inline ::google::internal::federated::plan::Plan_Phase* Plan::_internal_add_phase() {
  return _impl_.phase_.Add();
}
inline ::google::internal::federated::plan::Plan_Phase* Plan::add_phase() {
  ::google::internal::federated::plan::Plan_Phase* _add = _internal_add_phase();
  // @@protoc_insertion_point(field_add:google.internal.federated.plan.Plan.phase)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::Plan_Phase >&
Plan::phase() const {
  // @@protoc_insertion_point(field_list:google.internal.federated.plan.Plan.phase)
  return _impl_.phase_;
}

// repeated .google.internal.federated.plan.Metric metrics = 6;
inline int Plan::_internal_metrics_size() const {
  return _impl_.metrics_.size();
}
inline int Plan::metrics_size() const {
  return _internal_metrics_size();
}
inline void Plan::clear_metrics() {
  _impl_.metrics_.Clear();
}
inline ::google::internal::federated::plan::Metric* Plan::mutable_metrics(int index) {
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.Plan.metrics)
  return _impl_.metrics_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::Metric >*
Plan::mutable_metrics() {
  // @@protoc_insertion_point(field_mutable_list:google.internal.federated.plan.Plan.metrics)
  return &_impl_.metrics_;
}
inline const ::google::internal::federated::plan::Metric& Plan::_internal_metrics(int index) const {
  return _impl_.metrics_.Get(index);
}
inline const ::google::internal::federated::plan::Metric& Plan::metrics(int index) const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.Plan.metrics)
  return _internal_metrics(index);
}
inline ::google::internal::federated::plan::Metric* Plan::_internal_add_metrics() {
  return _impl_.metrics_.Add();
}
inline ::google::internal::federated::plan::Metric* Plan::add_metrics() {
  ::google::internal::federated::plan::Metric* _add = _internal_add_metrics();
  // @@protoc_insertion_point(field_add:google.internal.federated.plan.Plan.metrics)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::Metric >&
Plan::metrics() const {
  // @@protoc_insertion_point(field_list:google.internal.federated.plan.Plan.metrics)
  return _impl_.metrics_;
}

// repeated .google.internal.federated.plan.OutputMetric output_metrics = 10;
inline int Plan::_internal_output_metrics_size() const {
  return _impl_.output_metrics_.size();
}
inline int Plan::output_metrics_size() const {
  return _internal_output_metrics_size();
}
inline void Plan::clear_output_metrics() {
  _impl_.output_metrics_.Clear();
}
inline ::google::internal::federated::plan::OutputMetric* Plan::mutable_output_metrics(int index) {
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.Plan.output_metrics)
  return _impl_.output_metrics_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::OutputMetric >*
Plan::mutable_output_metrics() {
  // @@protoc_insertion_point(field_mutable_list:google.internal.federated.plan.Plan.output_metrics)
  return &_impl_.output_metrics_;
}
inline const ::google::internal::federated::plan::OutputMetric& Plan::_internal_output_metrics(int index) const {
  return _impl_.output_metrics_.Get(index);
}
inline const ::google::internal::federated::plan::OutputMetric& Plan::output_metrics(int index) const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.Plan.output_metrics)
  return _internal_output_metrics(index);
}
inline ::google::internal::federated::plan::OutputMetric* Plan::_internal_add_output_metrics() {
  return _impl_.output_metrics_.Add();
}
inline ::google::internal::federated::plan::OutputMetric* Plan::add_output_metrics() {
  ::google::internal::federated::plan::OutputMetric* _add = _internal_add_output_metrics();
  // @@protoc_insertion_point(field_add:google.internal.federated.plan.Plan.output_metrics)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::OutputMetric >&
Plan::output_metrics() const {
  // @@protoc_insertion_point(field_list:google.internal.federated.plan.Plan.output_metrics)
  return _impl_.output_metrics_;
}

// int32 version = 9;
inline void Plan::clear_version() {
  _impl_.version_ = 0;
}
inline ::int32_t Plan::_internal_version() const {
  return _impl_.version_;
}
inline ::int32_t Plan::version() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.Plan.version)
  return _internal_version();
}
inline void Plan::_internal_set_version(::int32_t value) {

  _impl_.version_ = value;
}
inline void Plan::set_version(::int32_t value) {
  _internal_set_version(value);
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.Plan.version)
}

// .google.protobuf.Any tensorflow_config_proto = 11;
inline bool Plan::_internal_has_tensorflow_config_proto() const {
  return this != internal_default_instance() && _impl_.tensorflow_config_proto_ != nullptr;
}
inline bool Plan::has_tensorflow_config_proto() const {
  return _internal_has_tensorflow_config_proto();
}
inline const ::PROTOBUF_NAMESPACE_ID::Any& Plan::_internal_tensorflow_config_proto() const {
  const ::PROTOBUF_NAMESPACE_ID::Any* p = _impl_.tensorflow_config_proto_;
  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Any&>(
      ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::Any& Plan::tensorflow_config_proto() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.Plan.tensorflow_config_proto)
  return _internal_tensorflow_config_proto();
}
inline void Plan::unsafe_arena_set_allocated_tensorflow_config_proto(
    ::PROTOBUF_NAMESPACE_ID::Any* tensorflow_config_proto) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.tensorflow_config_proto_);
  }
  _impl_.tensorflow_config_proto_ = tensorflow_config_proto;
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.Plan.tensorflow_config_proto)
}
inline ::PROTOBUF_NAMESPACE_ID::Any* Plan::release_tensorflow_config_proto() {

  ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.tensorflow_config_proto_;
  _impl_.tensorflow_config_proto_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* Plan::unsafe_arena_release_tensorflow_config_proto() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.Plan.tensorflow_config_proto)

  ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.tensorflow_config_proto_;
  _impl_.tensorflow_config_proto_ = nullptr;
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* Plan::_internal_mutable_tensorflow_config_proto() {

  if (_impl_.tensorflow_config_proto_ == nullptr) {
    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation());
    _impl_.tensorflow_config_proto_ = p;
  }
  return _impl_.tensorflow_config_proto_;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* Plan::mutable_tensorflow_config_proto() {
  ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_tensorflow_config_proto();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.Plan.tensorflow_config_proto)
  return _msg;
}
inline void Plan::set_allocated_tensorflow_config_proto(::PROTOBUF_NAMESPACE_ID::Any* tensorflow_config_proto) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.tensorflow_config_proto_);
  }
  if (tensorflow_config_proto) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tensorflow_config_proto));
    if (message_arena != submessage_arena) {
      tensorflow_config_proto = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, tensorflow_config_proto, submessage_arena);
    }

  } else {

  }
  _impl_.tensorflow_config_proto_ = tensorflow_config_proto;
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.Plan.tensorflow_config_proto)
}

// -------------------------------------------------------------------

// ClientOnlyPlan

// bytes graph = 1;
inline void ClientOnlyPlan::clear_graph() {
  _impl_.graph_.ClearToEmpty();
}
inline const std::string& ClientOnlyPlan::graph() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ClientOnlyPlan.graph)
  return _internal_graph();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClientOnlyPlan::set_graph(ArgT0&& arg0, ArgT... args) {

 _impl_.graph_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.ClientOnlyPlan.graph)
}
inline std::string* ClientOnlyPlan::mutable_graph() {
  std::string* _s = _internal_mutable_graph();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ClientOnlyPlan.graph)
  return _s;
}
inline const std::string& ClientOnlyPlan::_internal_graph() const {
  return _impl_.graph_.Get();
}
inline void ClientOnlyPlan::_internal_set_graph(const std::string& value) {

  _impl_.graph_.Set(value, GetArenaForAllocation());
}
inline std::string* ClientOnlyPlan::_internal_mutable_graph() {

  return _impl_.graph_.Mutable(GetArenaForAllocation());
}
inline std::string* ClientOnlyPlan::release_graph() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ClientOnlyPlan.graph)
  return _impl_.graph_.Release();
}
inline void ClientOnlyPlan::set_allocated_graph(std::string* graph) {
  _impl_.graph_.SetAllocated(graph, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.graph_.IsDefault()) {
    _impl_.graph_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ClientOnlyPlan.graph)
}

// bytes tflite_graph = 5;
inline void ClientOnlyPlan::clear_tflite_graph() {
  _impl_.tflite_graph_.ClearToEmpty();
}
inline const std::string& ClientOnlyPlan::tflite_graph() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ClientOnlyPlan.tflite_graph)
  return _internal_tflite_graph();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClientOnlyPlan::set_tflite_graph(ArgT0&& arg0, ArgT... args) {

 _impl_.tflite_graph_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.ClientOnlyPlan.tflite_graph)
}
inline std::string* ClientOnlyPlan::mutable_tflite_graph() {
  std::string* _s = _internal_mutable_tflite_graph();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ClientOnlyPlan.tflite_graph)
  return _s;
}
inline const std::string& ClientOnlyPlan::_internal_tflite_graph() const {
  return _impl_.tflite_graph_.Get();
}
inline void ClientOnlyPlan::_internal_set_tflite_graph(const std::string& value) {

  _impl_.tflite_graph_.Set(value, GetArenaForAllocation());
}
inline std::string* ClientOnlyPlan::_internal_mutable_tflite_graph() {

  return _impl_.tflite_graph_.Mutable(GetArenaForAllocation());
}
inline std::string* ClientOnlyPlan::release_tflite_graph() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ClientOnlyPlan.tflite_graph)
  return _impl_.tflite_graph_.Release();
}
inline void ClientOnlyPlan::set_allocated_tflite_graph(std::string* tflite_graph) {
  _impl_.tflite_graph_.SetAllocated(tflite_graph, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.tflite_graph_.IsDefault()) {
    _impl_.tflite_graph_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ClientOnlyPlan.tflite_graph)
}

// .google.internal.federated.plan.ClientPhase phase = 2;
inline bool ClientOnlyPlan::_internal_has_phase() const {
  return this != internal_default_instance() && _impl_.phase_ != nullptr;
}
inline bool ClientOnlyPlan::has_phase() const {
  return _internal_has_phase();
}
inline void ClientOnlyPlan::clear_phase() {
  if (GetArenaForAllocation() == nullptr && _impl_.phase_ != nullptr) {
    delete _impl_.phase_;
  }
  _impl_.phase_ = nullptr;
}
inline const ::google::internal::federated::plan::ClientPhase& ClientOnlyPlan::_internal_phase() const {
  const ::google::internal::federated::plan::ClientPhase* p = _impl_.phase_;
  return p != nullptr ? *p : reinterpret_cast<const ::google::internal::federated::plan::ClientPhase&>(
      ::google::internal::federated::plan::_ClientPhase_default_instance_);
}
inline const ::google::internal::federated::plan::ClientPhase& ClientOnlyPlan::phase() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ClientOnlyPlan.phase)
  return _internal_phase();
}
inline void ClientOnlyPlan::unsafe_arena_set_allocated_phase(
    ::google::internal::federated::plan::ClientPhase* phase) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.phase_);
  }
  _impl_.phase_ = phase;
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.ClientOnlyPlan.phase)
}
inline ::google::internal::federated::plan::ClientPhase* ClientOnlyPlan::release_phase() {

  ::google::internal::federated::plan::ClientPhase* temp = _impl_.phase_;
  _impl_.phase_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::google::internal::federated::plan::ClientPhase* ClientOnlyPlan::unsafe_arena_release_phase() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ClientOnlyPlan.phase)

  ::google::internal::federated::plan::ClientPhase* temp = _impl_.phase_;
  _impl_.phase_ = nullptr;
  return temp;
}
inline ::google::internal::federated::plan::ClientPhase* ClientOnlyPlan::_internal_mutable_phase() {

  if (_impl_.phase_ == nullptr) {
    auto* p = CreateMaybeMessage<::google::internal::federated::plan::ClientPhase>(GetArenaForAllocation());
    _impl_.phase_ = p;
  }
  return _impl_.phase_;
}
inline ::google::internal::federated::plan::ClientPhase* ClientOnlyPlan::mutable_phase() {
  ::google::internal::federated::plan::ClientPhase* _msg = _internal_mutable_phase();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ClientOnlyPlan.phase)
  return _msg;
}
inline void ClientOnlyPlan::set_allocated_phase(::google::internal::federated::plan::ClientPhase* phase) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.phase_;
  }
  if (phase) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(phase);
    if (message_arena != submessage_arena) {
      phase = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, phase, submessage_arena);
    }

  } else {

  }
  _impl_.phase_ = phase;
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ClientOnlyPlan.phase)
}

// .google.protobuf.Any tensorflow_config_proto = 4;
inline bool ClientOnlyPlan::_internal_has_tensorflow_config_proto() const {
  return this != internal_default_instance() && _impl_.tensorflow_config_proto_ != nullptr;
}
inline bool ClientOnlyPlan::has_tensorflow_config_proto() const {
  return _internal_has_tensorflow_config_proto();
}
inline const ::PROTOBUF_NAMESPACE_ID::Any& ClientOnlyPlan::_internal_tensorflow_config_proto() const {
  const ::PROTOBUF_NAMESPACE_ID::Any* p = _impl_.tensorflow_config_proto_;
  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Any&>(
      ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::Any& ClientOnlyPlan::tensorflow_config_proto() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.ClientOnlyPlan.tensorflow_config_proto)
  return _internal_tensorflow_config_proto();
}
inline void ClientOnlyPlan::unsafe_arena_set_allocated_tensorflow_config_proto(
    ::PROTOBUF_NAMESPACE_ID::Any* tensorflow_config_proto) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.tensorflow_config_proto_);
  }
  _impl_.tensorflow_config_proto_ = tensorflow_config_proto;
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.ClientOnlyPlan.tensorflow_config_proto)
}
inline ::PROTOBUF_NAMESPACE_ID::Any* ClientOnlyPlan::release_tensorflow_config_proto() {

  ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.tensorflow_config_proto_;
  _impl_.tensorflow_config_proto_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* ClientOnlyPlan::unsafe_arena_release_tensorflow_config_proto() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.ClientOnlyPlan.tensorflow_config_proto)

  ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.tensorflow_config_proto_;
  _impl_.tensorflow_config_proto_ = nullptr;
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* ClientOnlyPlan::_internal_mutable_tensorflow_config_proto() {

  if (_impl_.tensorflow_config_proto_ == nullptr) {
    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation());
    _impl_.tensorflow_config_proto_ = p;
  }
  return _impl_.tensorflow_config_proto_;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* ClientOnlyPlan::mutable_tensorflow_config_proto() {
  ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_tensorflow_config_proto();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.ClientOnlyPlan.tensorflow_config_proto)
  return _msg;
}
inline void ClientOnlyPlan::set_allocated_tensorflow_config_proto(::PROTOBUF_NAMESPACE_ID::Any* tensorflow_config_proto) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.tensorflow_config_proto_);
  }
  if (tensorflow_config_proto) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tensorflow_config_proto));
    if (message_arena != submessage_arena) {
      tensorflow_config_proto = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, tensorflow_config_proto, submessage_arena);
    }

  } else {

  }
  _impl_.tensorflow_config_proto_ = tensorflow_config_proto;
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.ClientOnlyPlan.tensorflow_config_proto)
}

// -------------------------------------------------------------------

// CrossRoundAggregationExecution

// string init_op = 1;
inline void CrossRoundAggregationExecution::clear_init_op() {
  _impl_.init_op_.ClearToEmpty();
}
inline const std::string& CrossRoundAggregationExecution::init_op() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.CrossRoundAggregationExecution.init_op)
  return _internal_init_op();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CrossRoundAggregationExecution::set_init_op(ArgT0&& arg0, ArgT... args) {

 _impl_.init_op_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.CrossRoundAggregationExecution.init_op)
}
inline std::string* CrossRoundAggregationExecution::mutable_init_op() {
  std::string* _s = _internal_mutable_init_op();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.CrossRoundAggregationExecution.init_op)
  return _s;
}
inline const std::string& CrossRoundAggregationExecution::_internal_init_op() const {
  return _impl_.init_op_.Get();
}
inline void CrossRoundAggregationExecution::_internal_set_init_op(const std::string& value) {

  _impl_.init_op_.Set(value, GetArenaForAllocation());
}
inline std::string* CrossRoundAggregationExecution::_internal_mutable_init_op() {

  return _impl_.init_op_.Mutable(GetArenaForAllocation());
}
inline std::string* CrossRoundAggregationExecution::release_init_op() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.CrossRoundAggregationExecution.init_op)
  return _impl_.init_op_.Release();
}
inline void CrossRoundAggregationExecution::set_allocated_init_op(std::string* init_op) {
  _impl_.init_op_.SetAllocated(init_op, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.init_op_.IsDefault()) {
    _impl_.init_op_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.CrossRoundAggregationExecution.init_op)
}

// .google.internal.federated.plan.CheckpointOp read_aggregated_update = 2;
inline bool CrossRoundAggregationExecution::_internal_has_read_aggregated_update() const {
  return this != internal_default_instance() && _impl_.read_aggregated_update_ != nullptr;
}
inline bool CrossRoundAggregationExecution::has_read_aggregated_update() const {
  return _internal_has_read_aggregated_update();
}
inline void CrossRoundAggregationExecution::clear_read_aggregated_update() {
  if (GetArenaForAllocation() == nullptr && _impl_.read_aggregated_update_ != nullptr) {
    delete _impl_.read_aggregated_update_;
  }
  _impl_.read_aggregated_update_ = nullptr;
}
inline const ::google::internal::federated::plan::CheckpointOp& CrossRoundAggregationExecution::_internal_read_aggregated_update() const {
  const ::google::internal::federated::plan::CheckpointOp* p = _impl_.read_aggregated_update_;
  return p != nullptr ? *p : reinterpret_cast<const ::google::internal::federated::plan::CheckpointOp&>(
      ::google::internal::federated::plan::_CheckpointOp_default_instance_);
}
inline const ::google::internal::federated::plan::CheckpointOp& CrossRoundAggregationExecution::read_aggregated_update() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.CrossRoundAggregationExecution.read_aggregated_update)
  return _internal_read_aggregated_update();
}
inline void CrossRoundAggregationExecution::unsafe_arena_set_allocated_read_aggregated_update(
    ::google::internal::federated::plan::CheckpointOp* read_aggregated_update) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.read_aggregated_update_);
  }
  _impl_.read_aggregated_update_ = read_aggregated_update;
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.CrossRoundAggregationExecution.read_aggregated_update)
}
inline ::google::internal::federated::plan::CheckpointOp* CrossRoundAggregationExecution::release_read_aggregated_update() {

  ::google::internal::federated::plan::CheckpointOp* temp = _impl_.read_aggregated_update_;
  _impl_.read_aggregated_update_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::google::internal::federated::plan::CheckpointOp* CrossRoundAggregationExecution::unsafe_arena_release_read_aggregated_update() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.CrossRoundAggregationExecution.read_aggregated_update)

  ::google::internal::federated::plan::CheckpointOp* temp = _impl_.read_aggregated_update_;
  _impl_.read_aggregated_update_ = nullptr;
  return temp;
}
inline ::google::internal::federated::plan::CheckpointOp* CrossRoundAggregationExecution::_internal_mutable_read_aggregated_update() {

  if (_impl_.read_aggregated_update_ == nullptr) {
    auto* p = CreateMaybeMessage<::google::internal::federated::plan::CheckpointOp>(GetArenaForAllocation());
    _impl_.read_aggregated_update_ = p;
  }
  return _impl_.read_aggregated_update_;
}
inline ::google::internal::federated::plan::CheckpointOp* CrossRoundAggregationExecution::mutable_read_aggregated_update() {
  ::google::internal::federated::plan::CheckpointOp* _msg = _internal_mutable_read_aggregated_update();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.CrossRoundAggregationExecution.read_aggregated_update)
  return _msg;
}
inline void CrossRoundAggregationExecution::set_allocated_read_aggregated_update(::google::internal::federated::plan::CheckpointOp* read_aggregated_update) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.read_aggregated_update_;
  }
  if (read_aggregated_update) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(read_aggregated_update);
    if (message_arena != submessage_arena) {
      read_aggregated_update = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, read_aggregated_update, submessage_arena);
    }

  } else {

  }
  _impl_.read_aggregated_update_ = read_aggregated_update;
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.CrossRoundAggregationExecution.read_aggregated_update)
}

// string merge_op = 3;
inline void CrossRoundAggregationExecution::clear_merge_op() {
  _impl_.merge_op_.ClearToEmpty();
}
inline const std::string& CrossRoundAggregationExecution::merge_op() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.CrossRoundAggregationExecution.merge_op)
  return _internal_merge_op();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CrossRoundAggregationExecution::set_merge_op(ArgT0&& arg0, ArgT... args) {

 _impl_.merge_op_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.CrossRoundAggregationExecution.merge_op)
}
inline std::string* CrossRoundAggregationExecution::mutable_merge_op() {
  std::string* _s = _internal_mutable_merge_op();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.CrossRoundAggregationExecution.merge_op)
  return _s;
}
inline const std::string& CrossRoundAggregationExecution::_internal_merge_op() const {
  return _impl_.merge_op_.Get();
}
inline void CrossRoundAggregationExecution::_internal_set_merge_op(const std::string& value) {

  _impl_.merge_op_.Set(value, GetArenaForAllocation());
}
inline std::string* CrossRoundAggregationExecution::_internal_mutable_merge_op() {

  return _impl_.merge_op_.Mutable(GetArenaForAllocation());
}
inline std::string* CrossRoundAggregationExecution::release_merge_op() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.CrossRoundAggregationExecution.merge_op)
  return _impl_.merge_op_.Release();
}
inline void CrossRoundAggregationExecution::set_allocated_merge_op(std::string* merge_op) {
  _impl_.merge_op_.SetAllocated(merge_op, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.merge_op_.IsDefault()) {
    _impl_.merge_op_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.CrossRoundAggregationExecution.merge_op)
}

// .google.internal.federated.plan.CheckpointOp read_write_final_accumulators = 6;
inline bool CrossRoundAggregationExecution::_internal_has_read_write_final_accumulators() const {
  return this != internal_default_instance() && _impl_.read_write_final_accumulators_ != nullptr;
}
inline bool CrossRoundAggregationExecution::has_read_write_final_accumulators() const {
  return _internal_has_read_write_final_accumulators();
}
inline void CrossRoundAggregationExecution::clear_read_write_final_accumulators() {
  if (GetArenaForAllocation() == nullptr && _impl_.read_write_final_accumulators_ != nullptr) {
    delete _impl_.read_write_final_accumulators_;
  }
  _impl_.read_write_final_accumulators_ = nullptr;
}
inline const ::google::internal::federated::plan::CheckpointOp& CrossRoundAggregationExecution::_internal_read_write_final_accumulators() const {
  const ::google::internal::federated::plan::CheckpointOp* p = _impl_.read_write_final_accumulators_;
  return p != nullptr ? *p : reinterpret_cast<const ::google::internal::federated::plan::CheckpointOp&>(
      ::google::internal::federated::plan::_CheckpointOp_default_instance_);
}
inline const ::google::internal::federated::plan::CheckpointOp& CrossRoundAggregationExecution::read_write_final_accumulators() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.CrossRoundAggregationExecution.read_write_final_accumulators)
  return _internal_read_write_final_accumulators();
}
inline void CrossRoundAggregationExecution::unsafe_arena_set_allocated_read_write_final_accumulators(
    ::google::internal::federated::plan::CheckpointOp* read_write_final_accumulators) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.read_write_final_accumulators_);
  }
  _impl_.read_write_final_accumulators_ = read_write_final_accumulators;
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.CrossRoundAggregationExecution.read_write_final_accumulators)
}
inline ::google::internal::federated::plan::CheckpointOp* CrossRoundAggregationExecution::release_read_write_final_accumulators() {

  ::google::internal::federated::plan::CheckpointOp* temp = _impl_.read_write_final_accumulators_;
  _impl_.read_write_final_accumulators_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::google::internal::federated::plan::CheckpointOp* CrossRoundAggregationExecution::unsafe_arena_release_read_write_final_accumulators() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.CrossRoundAggregationExecution.read_write_final_accumulators)

  ::google::internal::federated::plan::CheckpointOp* temp = _impl_.read_write_final_accumulators_;
  _impl_.read_write_final_accumulators_ = nullptr;
  return temp;
}
inline ::google::internal::federated::plan::CheckpointOp* CrossRoundAggregationExecution::_internal_mutable_read_write_final_accumulators() {

  if (_impl_.read_write_final_accumulators_ == nullptr) {
    auto* p = CreateMaybeMessage<::google::internal::federated::plan::CheckpointOp>(GetArenaForAllocation());
    _impl_.read_write_final_accumulators_ = p;
  }
  return _impl_.read_write_final_accumulators_;
}
inline ::google::internal::federated::plan::CheckpointOp* CrossRoundAggregationExecution::mutable_read_write_final_accumulators() {
  ::google::internal::federated::plan::CheckpointOp* _msg = _internal_mutable_read_write_final_accumulators();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.CrossRoundAggregationExecution.read_write_final_accumulators)
  return _msg;
}
inline void CrossRoundAggregationExecution::set_allocated_read_write_final_accumulators(::google::internal::federated::plan::CheckpointOp* read_write_final_accumulators) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.read_write_final_accumulators_;
  }
  if (read_write_final_accumulators) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(read_write_final_accumulators);
    if (message_arena != submessage_arena) {
      read_write_final_accumulators = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, read_write_final_accumulators, submessage_arena);
    }

  } else {

  }
  _impl_.read_write_final_accumulators_ = read_write_final_accumulators;
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.CrossRoundAggregationExecution.read_write_final_accumulators)
}

// repeated .google.internal.federated.plan.Measurement measurements = 4;
inline int CrossRoundAggregationExecution::_internal_measurements_size() const {
  return _impl_.measurements_.size();
}
inline int CrossRoundAggregationExecution::measurements_size() const {
  return _internal_measurements_size();
}
inline void CrossRoundAggregationExecution::clear_measurements() {
  _impl_.measurements_.Clear();
}
inline ::google::internal::federated::plan::Measurement* CrossRoundAggregationExecution::mutable_measurements(int index) {
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.CrossRoundAggregationExecution.measurements)
  return _impl_.measurements_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::Measurement >*
CrossRoundAggregationExecution::mutable_measurements() {
  // @@protoc_insertion_point(field_mutable_list:google.internal.federated.plan.CrossRoundAggregationExecution.measurements)
  return &_impl_.measurements_;
}
inline const ::google::internal::federated::plan::Measurement& CrossRoundAggregationExecution::_internal_measurements(int index) const {
  return _impl_.measurements_.Get(index);
}
inline const ::google::internal::federated::plan::Measurement& CrossRoundAggregationExecution::measurements(int index) const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.CrossRoundAggregationExecution.measurements)
  return _internal_measurements(index);
}
inline ::google::internal::federated::plan::Measurement* CrossRoundAggregationExecution::_internal_add_measurements() {
  return _impl_.measurements_.Add();
}
inline ::google::internal::federated::plan::Measurement* CrossRoundAggregationExecution::add_measurements() {
  ::google::internal::federated::plan::Measurement* _add = _internal_add_measurements();
  // @@protoc_insertion_point(field_add:google.internal.federated.plan.CrossRoundAggregationExecution.measurements)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::google::internal::federated::plan::Measurement >&
CrossRoundAggregationExecution::measurements() const {
  // @@protoc_insertion_point(field_list:google.internal.federated.plan.CrossRoundAggregationExecution.measurements)
  return _impl_.measurements_;
}

// .google.protobuf.Any cross_round_aggregation_graph_bytes = 5;
inline bool CrossRoundAggregationExecution::_internal_has_cross_round_aggregation_graph_bytes() const {
  return this != internal_default_instance() && _impl_.cross_round_aggregation_graph_bytes_ != nullptr;
}
inline bool CrossRoundAggregationExecution::has_cross_round_aggregation_graph_bytes() const {
  return _internal_has_cross_round_aggregation_graph_bytes();
}
inline const ::PROTOBUF_NAMESPACE_ID::Any& CrossRoundAggregationExecution::_internal_cross_round_aggregation_graph_bytes() const {
  const ::PROTOBUF_NAMESPACE_ID::Any* p = _impl_.cross_round_aggregation_graph_bytes_;
  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Any&>(
      ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_);
}
inline const ::PROTOBUF_NAMESPACE_ID::Any& CrossRoundAggregationExecution::cross_round_aggregation_graph_bytes() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.CrossRoundAggregationExecution.cross_round_aggregation_graph_bytes)
  return _internal_cross_round_aggregation_graph_bytes();
}
inline void CrossRoundAggregationExecution::unsafe_arena_set_allocated_cross_round_aggregation_graph_bytes(
    ::PROTOBUF_NAMESPACE_ID::Any* cross_round_aggregation_graph_bytes) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cross_round_aggregation_graph_bytes_);
  }
  _impl_.cross_round_aggregation_graph_bytes_ = cross_round_aggregation_graph_bytes;
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.internal.federated.plan.CrossRoundAggregationExecution.cross_round_aggregation_graph_bytes)
}
inline ::PROTOBUF_NAMESPACE_ID::Any* CrossRoundAggregationExecution::release_cross_round_aggregation_graph_bytes() {

  ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.cross_round_aggregation_graph_bytes_;
  _impl_.cross_round_aggregation_graph_bytes_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* CrossRoundAggregationExecution::unsafe_arena_release_cross_round_aggregation_graph_bytes() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.CrossRoundAggregationExecution.cross_round_aggregation_graph_bytes)

  ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.cross_round_aggregation_graph_bytes_;
  _impl_.cross_round_aggregation_graph_bytes_ = nullptr;
  return temp;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* CrossRoundAggregationExecution::_internal_mutable_cross_round_aggregation_graph_bytes() {

  if (_impl_.cross_round_aggregation_graph_bytes_ == nullptr) {
    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation());
    _impl_.cross_round_aggregation_graph_bytes_ = p;
  }
  return _impl_.cross_round_aggregation_graph_bytes_;
}
inline ::PROTOBUF_NAMESPACE_ID::Any* CrossRoundAggregationExecution::mutable_cross_round_aggregation_graph_bytes() {
  ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_cross_round_aggregation_graph_bytes();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.CrossRoundAggregationExecution.cross_round_aggregation_graph_bytes)
  return _msg;
}
inline void CrossRoundAggregationExecution::set_allocated_cross_round_aggregation_graph_bytes(::PROTOBUF_NAMESPACE_ID::Any* cross_round_aggregation_graph_bytes) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cross_round_aggregation_graph_bytes_);
  }
  if (cross_round_aggregation_graph_bytes) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(cross_round_aggregation_graph_bytes));
    if (message_arena != submessage_arena) {
      cross_round_aggregation_graph_bytes = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cross_round_aggregation_graph_bytes, submessage_arena);
    }

  } else {

  }
  _impl_.cross_round_aggregation_graph_bytes_ = cross_round_aggregation_graph_bytes;
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.CrossRoundAggregationExecution.cross_round_aggregation_graph_bytes)
}

// -------------------------------------------------------------------

// Measurement

// string read_op_name = 1;
inline void Measurement::clear_read_op_name() {
  _impl_.read_op_name_.ClearToEmpty();
}
inline const std::string& Measurement::read_op_name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.Measurement.read_op_name)
  return _internal_read_op_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Measurement::set_read_op_name(ArgT0&& arg0, ArgT... args) {

 _impl_.read_op_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.Measurement.read_op_name)
}
inline std::string* Measurement::mutable_read_op_name() {
  std::string* _s = _internal_mutable_read_op_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.Measurement.read_op_name)
  return _s;
}
inline const std::string& Measurement::_internal_read_op_name() const {
  return _impl_.read_op_name_.Get();
}
inline void Measurement::_internal_set_read_op_name(const std::string& value) {

  _impl_.read_op_name_.Set(value, GetArenaForAllocation());
}
inline std::string* Measurement::_internal_mutable_read_op_name() {

  return _impl_.read_op_name_.Mutable(GetArenaForAllocation());
}
inline std::string* Measurement::release_read_op_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.Measurement.read_op_name)
  return _impl_.read_op_name_.Release();
}
inline void Measurement::set_allocated_read_op_name(std::string* read_op_name) {
  _impl_.read_op_name_.SetAllocated(read_op_name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.read_op_name_.IsDefault()) {
    _impl_.read_op_name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.Measurement.read_op_name)
}

// string name = 2;
inline void Measurement::clear_name() {
  _impl_.name_.ClearToEmpty();
}
inline const std::string& Measurement::name() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.Measurement.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Measurement::set_name(ArgT0&& arg0, ArgT... args) {

 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.Measurement.name)
}
inline std::string* Measurement::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.Measurement.name)
  return _s;
}
inline const std::string& Measurement::_internal_name() const {
  return _impl_.name_.Get();
}
inline void Measurement::_internal_set_name(const std::string& value) {

  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* Measurement::_internal_mutable_name() {

  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* Measurement::release_name() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.Measurement.name)
  return _impl_.name_.Release();
}
inline void Measurement::set_allocated_name(std::string* name) {
  _impl_.name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.Measurement.name)
}

// bytes tff_type = 4;
inline void Measurement::clear_tff_type() {
  _impl_.tff_type_.ClearToEmpty();
}
inline const std::string& Measurement::tff_type() const {
  // @@protoc_insertion_point(field_get:google.internal.federated.plan.Measurement.tff_type)
  return _internal_tff_type();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Measurement::set_tff_type(ArgT0&& arg0, ArgT... args) {

 _impl_.tff_type_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:google.internal.federated.plan.Measurement.tff_type)
}
inline std::string* Measurement::mutable_tff_type() {
  std::string* _s = _internal_mutable_tff_type();
  // @@protoc_insertion_point(field_mutable:google.internal.federated.plan.Measurement.tff_type)
  return _s;
}
inline const std::string& Measurement::_internal_tff_type() const {
  return _impl_.tff_type_.Get();
}
inline void Measurement::_internal_set_tff_type(const std::string& value) {

  _impl_.tff_type_.Set(value, GetArenaForAllocation());
}
inline std::string* Measurement::_internal_mutable_tff_type() {

  return _impl_.tff_type_.Mutable(GetArenaForAllocation());
}
inline std::string* Measurement::release_tff_type() {
  // @@protoc_insertion_point(field_release:google.internal.federated.plan.Measurement.tff_type)
  return _impl_.tff_type_.Release();
}
inline void Measurement::set_allocated_tff_type(std::string* tff_type) {
  _impl_.tff_type_.SetAllocated(tff_type, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.tff_type_.IsDefault()) {
    _impl_.tff_type_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:google.internal.federated.plan.Measurement.tff_type)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace plan
}  // namespace federated
}  // namespace internal
}  // namespace google

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::google::internal::federated::plan::VisualizationSpec_VisualizationType> : ::std::true_type {};
template <> struct is_proto_enum< ::google::internal::federated::plan::ExampleQuerySpec_OutputVectorSpec_DataType> : ::std::true_type {};

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_fcp_2fprotos_2fplan_2eproto