v0

type AbstractType struct {

	// The label used to refer to this abstract type within a type signature.
	Label string `protobuf:"bytes,1,opt,name=label,proto3" json:"label,omitempty"`
	// contains filtered or unexported fields
}

type Block struct {

	// One or more locals defined within the block, each associating a name with a
	// computation. Computations, whether those associated with the locals, or
	// that associated with the result below, can contain references to names
	// defined earlier, here or in the surrounding context. Self-references are
	// prohibited. All names introduced here must be different. Since execution
	// semantics at this level is purely functional without side effects, the
	// ordering in which the locals are declared is not significant, as it is only
	// the dependencies between the computations that effectively determine the
	// causal relationships that constrain the order of execution.
	//
	// Blocks can be nested, just as lambdas, and the same name scoping rules
	// apply, i.e., blocks (or lambdas) contained within an embedded computation,
	// whether in a local or in the result, are allowed to refer to names defined
	// in an outer lambda or block (unless obscured by a nested declaration).
	// If names defined in the outer context conflict with those defined in the
	// inner congtext (here), the inner names hide outer names in the context in
	// which they are defined. Thus, for example, in "x -> let x=1, y=x+1 in y",
	// the "x=1" would hide the lambda parameter, and therefore "y=x+1" would
	// refer to the inner "x".
	Local []*Block_Local `protobuf:"bytes,1,rep,name=local,proto3" json:"local,omitempty"`
	// The result computation. Always required. The computation typically refers
	// to locals defined above by name, just like the result in a lambda.
	Result *Computation `protobuf:"bytes,2,opt,name=result,proto3" json:"result,omitempty"`
	// contains filtered or unexported fields
}

type Block_Local struct {
	Name  string       `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Value *Computation `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type Call struct {

	// A computation that represents the function to call. The value that this
	// represents must be of a functional type.
	Function *Computation `protobuf:"bytes,1,opt,name=function,proto3" json:"function,omitempty"`
	// A computation that represents the argument to the function specified above.
	// Present if and only if "function" declares a parameter. Must match the
	// function's parameter type (i.e., the function's parameter type must be
	// assignable from the argument type).
	Argument *Computation `protobuf:"bytes,2,opt,name=argument,proto3" json:"argument,omitempty"`
	// contains filtered or unexported fields
}

type Cardinality struct {
	Placement   *Placement `protobuf:"bytes,1,opt,name=placement,proto3" json:"placement,omitempty"`
	Cardinality int32      `protobuf:"varint,2,opt,name=cardinality,proto3" json:"cardinality,omitempty"`
	// contains filtered or unexported fields
}

type Computation struct {

	// The type of what's represented by this structure, which may be functional
	// or non-functional. If it is a TensorFlow block or a lambda expression,
	// the type will be functional. If it is a Struct, or a Call that returns a
	// tensor or a Struct in the result, the type will be non-functional.
	//
	// A Call is a typical way to represent an invocation of a top-level federated
	// computation with all its parameters fully specified. Thus, a top-level
	// computation with all of its parameters filled in may have a non-functional
	// type (the same as type of the result it computes). The illustrative
	// example to think of is "(x -> x + 10)(20)", the type of which is an int, a
	// non-functional type. If a top-level federated computation has all of its
	// parameters filled in, it will assume a similar form.
	Type *Type `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	// The specification of the computation to perform.
	//
	// A hypothetical example of a federated computation definition in Python,
	// expressed in a yet-to-be-defined syntax, might translate into definitions
	// in a serialized form as shown below.
	//
	// @tff.computation
	// def fed_eval(model):
	//
	//   @tfe.defun
	//   def local_eval(model):
	//     ...
	//     return {'loss': ..., 'accuracy': ...}
	//
	//   client_model = tff.federated_broadcast(model)
	//   client_metrics = tff.federated_map(local_eval, client_model)
	//   return tff.federated_mean(client_metrics)
	//
	//
	// fed_eval = Computation(lambda=Lambda(
	//     parameter_name='model',
	//     result=Computation(block=Block(
	//         local=[
	//             Block.Local(name='local_eval', value=Computation(
	//                 tensorflow=TensorFlow(...))),
	//             Block.Local(name='client_model', value=Computation(
	//                 call=Call(
	//                     function=Computation(
	//                         intrinsic=Intrinsic(uri='federated_broadcast')),
	//                     argument=Computation(
	//                         reference=Reference(name='model'))))),
	//             Block.Local(name='client_metrics', value=Computation(
	//                 call=Call(
	//                     function=Computation(
	//                         intrinsic=Intrinsic(uri='federated_map')),
	//                     argument=Computation(
	//                         struct=Struct(element=[
	//                             Struct.Element(
	//                                 value=Computation(
	//                                     reference=Reference(
	//                                         name='local_eval'))),
	//                             Struct.Element(
	//                                 value=Computation(
	//                                     reference=Reference(
	//                                         name='local_client_model')))
	//                         ])))))],
	//         result=Computation(
	//             call=Call(
	//                 function=Computation(
	//                     intrinsic=Intrinsic(uri='federated_mean')),
	//                 argument=Computation(
	//                     reference=Reference(name='client_metrics'))))))))
	//
	//
	// Types that are assignable to Computation:
	//	*Computation_Tensorflow
	//	*Computation_Intrinsic
	//	*Computation_Data
	//	*Computation_Lambda
	//	*Computation_Block
	//	*Computation_Reference
	//	*Computation_Call
	//	*Computation_Struct
	//	*Computation_Selection
	//	*Computation_Placement
	//	*Computation_Xla
	Computation isComputation_Computation `protobuf_oneof:"computation"`
	// contains filtered or unexported fields
}

type Computation_Block struct {
	// A block of computation logic, i.e., a series of expressions that refer
	// to one-another. This mechanism is intended as a primary means of
	// breaking down longer sequences of processing into simpler parts. A block
	// can have a functional or a non-functional type (matching the type of its
	// result), as it is primarily a mechanism for organizing code.
	Block *Block `protobuf:"bytes,5,opt,name=block,proto3,oneof"`
}

type Computation_Call struct {
	// A function call is the primary means of using lambdas, TensorFlow blocks,
	// and other types of functional constructs to compute a specific result in
	// a concrete context. The type of the call is the same as the type of the
	// result of the function being called, i.e., a call with parameter of type
	// T to a function of type T -> T' has type T'.
	Call *Call `protobuf:"bytes,7,opt,name=call,proto3,oneof"`
}

type Computation_Data struct {
	// An external source of data to be used by a computation.
	Data *Data `protobuf:"bytes,10,opt,name=data,proto3,oneof"`
}

type Computation_Intrinsic struct {
	// A built-in federated communication operator such as broadcast, federated
	// sum, etc., or one of the custom operators added to the framework, and
	// recognized by the compiler pipeline. Intrinsics have functional types,
	// and most are defined as templates that can opperate on abstract types,
	// and/or federated values with arbitrary placements.
	Intrinsic *Intrinsic `protobuf:"bytes,3,opt,name=intrinsic,proto3,oneof"`
}

type Computation_Lambda struct {
	// A lambda expression is the primary means of defining new parameterized
	// computations. lambdas always have functional types.
	Lambda *Lambda `protobuf:"bytes,4,opt,name=lambda,proto3,oneof"`
}

type Computation_Placement struct {
	// A placement literal.
	Placement *Placement `protobuf:"bytes,11,opt,name=placement,proto3,oneof"`
}

type Computation_Reference struct {
	// A reference to a name defined in a surrounding context, such as a Lambda
	// or a Block, with the usual scoping rules (the name refers to the
	// innermost scope in which it is defined). Always matches the type of the
	// the parameter it references, i.e., T if the type of the lambda is T->T'.
	// For example, in a Lambda "x : int -> foo(x)", which associates locally
	// name "x" with its parameter, the reference to "x" will be of type "int",
	// just as the parameter of the lambda in which the name "x" is defined.
	Reference *Reference `protobuf:"bytes,6,opt,name=reference,proto3,oneof"`
}

type Computation_Selection struct {
	// A selection by name or index from the result of another expression that
	// returns a Struct. The type of the selection matches the type of the
	// Struct element being selected (known statically, as the name or index is
	// known statically, rather than computed).
	//
	// Note: In higher layers of the API, we will offer convenience mechanisms
	// such as selection from a federated type. For example, if "x" is of a
	// federated type "{<foo=int, bar=string>}@clients", we will allow notation
	// such as "x.foo" as a convenient shortcut for a pointwise selection that
	// might be written as "federated_map(x, y->y.foo)" in a more complete form
	// even though "x" is technically not a Struct. Here at the level of
	// the Computation proto, however, we will represent computations in their
	// fully fleshed-out form, with map and other implicit operators already
	// injected at construction time by the framework as it translates a Python
	// source cosde that defines a computation into this serialized form.
	Selection *Selection `protobuf:"bytes,9,opt,name=selection,proto3,oneof"`
}

type Computation_Struct struct {
	// A struct is explicitly constructed from individual member values.
	Struct *Struct `protobuf:"bytes,8,opt,name=struct,proto3,oneof"`
}

type Computation_Tensorflow struct {
	// TensorFlow computation. TensorFlow computations have functional type
	// signatures that cannot contain FederatedTypes, as they execute locally.
	// In order to construct a TensorFlow computation that maps a federated
	// value pointwise, one must use a federated map intrinsic (to be defined).
	Tensorflow *TensorFlow `protobuf:"bytes,2,opt,name=tensorflow,proto3,oneof"`
}

type Computation_Xla struct {
	// A local (non-federated) computation expressed in XLA. XLA computations
	// have functional type signatures, and are used in a manner similar to
	// local computations expressed in TensorFlow. However, not all types of
	// TensorFlow computations are expressible in XLA (see below for the list
	// of current limitations).
	Xla *Xla `protobuf:"bytes,12,opt,name=xla,proto3,oneof"`
}

type ComputeRequest struct {
	ValueRef *ValueRef   `protobuf:"bytes,1,opt,name=value_ref,json=valueRef,proto3" json:"value_ref,omitempty"`
	Executor *ExecutorId `protobuf:"bytes,2,opt,name=executor,proto3" json:"executor,omitempty"`
	// contains filtered or unexported fields
}

type ComputeResponse struct {
	Value *Value `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type CreateCallRequest struct {

	// A reference to the function to be called (which must be obtained from a
	// prior call to `CreateValue()`).
	FunctionRef *ValueRef `protobuf:"bytes,1,opt,name=function_ref,json=functionRef,proto3" json:"function_ref,omitempty"`
	// An optional argument, only for functions that declare an argument.
	ArgumentRef *ValueRef   `protobuf:"bytes,2,opt,name=argument_ref,json=argumentRef,proto3" json:"argument_ref,omitempty"`
	Executor    *ExecutorId `protobuf:"bytes,3,opt,name=executor,proto3" json:"executor,omitempty"`
	// contains filtered or unexported fields
}

type CreateCallResponse struct {
	ValueRef *ValueRef `protobuf:"bytes,1,opt,name=value_ref,json=valueRef,proto3" json:"value_ref,omitempty"`
	// contains filtered or unexported fields
}

type CreateSelectionRequest struct {
	SourceRef *ValueRef   `protobuf:"bytes,1,opt,name=source_ref,json=sourceRef,proto3" json:"source_ref,omitempty"`
	Index     int32       `protobuf:"varint,3,opt,name=index,proto3" json:"index,omitempty"`
	Executor  *ExecutorId `protobuf:"bytes,4,opt,name=executor,proto3" json:"executor,omitempty"`
	// contains filtered or unexported fields
}

type CreateSelectionResponse struct {
	ValueRef *ValueRef `protobuf:"bytes,1,opt,name=value_ref,json=valueRef,proto3" json:"value_ref,omitempty"`
	// contains filtered or unexported fields
}

type CreateStructRequest struct {
	Element  []*CreateStructRequest_Element `protobuf:"bytes,1,rep,name=element,proto3" json:"element,omitempty"`
	Executor *ExecutorId                    `protobuf:"bytes,3,opt,name=executor,proto3" json:"executor,omitempty"`
	// contains filtered or unexported fields
}

type CreateStructRequest_Element struct {
	Name     string    `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	ValueRef *ValueRef `protobuf:"bytes,2,opt,name=value_ref,json=valueRef,proto3" json:"value_ref,omitempty"`
	// contains filtered or unexported fields
}

type CreateStructResponse struct {
	ValueRef *ValueRef `protobuf:"bytes,1,opt,name=value_ref,json=valueRef,proto3" json:"value_ref,omitempty"`
	// contains filtered or unexported fields
}

type CreateValueRequest struct {
	Value    *Value      `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	Executor *ExecutorId `protobuf:"bytes,2,opt,name=executor,proto3" json:"executor,omitempty"`
	// contains filtered or unexported fields
}

type CreateValueResponse struct {
	ValueRef *ValueRef `protobuf:"bytes,1,opt,name=value_ref,json=valueRef,proto3" json:"value_ref,omitempty"`
	// contains filtered or unexported fields
}

type Data struct {

	// Types that are assignable to Data:
	//	*Data_Uri
	Data isData_Data `protobuf_oneof:"data"`
	// contains filtered or unexported fields
}

type Data_Uri struct {
	// A specification of the data stream as a URI to be interpreted by the
	// environment.
	Uri string `protobuf:"bytes,1,opt,name=uri,proto3,oneof"`
}

type DisposeExecutorRequest struct {
	Executor *ExecutorId `protobuf:"bytes,1,opt,name=executor,proto3" json:"executor,omitempty"`
	// contains filtered or unexported fields
}

type DisposeExecutorResponse struct {
	// contains filtered or unexported fields
}

type DisposeRequest struct {
	ValueRef []*ValueRef `protobuf:"bytes,1,rep,name=value_ref,json=valueRef,proto3" json:"value_ref,omitempty"`
	Executor *ExecutorId `protobuf:"bytes,2,opt,name=executor,proto3" json:"executor,omitempty"`
	// contains filtered or unexported fields
}

type DisposeResponse struct {
	// contains filtered or unexported fields
}

type ExecutorGroupClient interface {
	// Returns a
	GetExecutor(ctx context.Context, in *GetExecutorRequest, opts ...grpc.CallOption) (*GetExecutorResponse, error)
	// Creates a value in the executor and returns a reference to it that can be
	// supplied as an argument to other methods.
	CreateValue(ctx context.Context, in *CreateValueRequest, opts ...grpc.CallOption) (*CreateValueResponse, error)
	// Creates a call in the executor and returns a reference to the result.
	CreateCall(ctx context.Context, in *CreateCallRequest, opts ...grpc.CallOption) (*CreateCallResponse, error)
	// Creates a struct of values in the executor and returns a reference to it.
	CreateStruct(ctx context.Context, in *CreateStructRequest, opts ...grpc.CallOption) (*CreateStructResponse, error)
	// Creates a selection from an executor value and returns a reference to it.
	CreateSelection(ctx context.Context, in *CreateSelectionRequest, opts ...grpc.CallOption) (*CreateSelectionResponse, error)
	// Causes a value in the executor to get computed, and sends back the result.
	// WARNING: Unlike all other methods in this API, this may be a long-running
	// call (it will block until the value becomes available).
	Compute(ctx context.Context, in *ComputeRequest, opts ...grpc.CallOption) (*ComputeResponse, error)
	// Causes one or more values in the executor to get disposed of (no longer
	// available for future calls).
	Dispose(ctx context.Context, in *DisposeRequest, opts ...grpc.CallOption) (*DisposeResponse, error)
	// Causes an executor to be disposed of (no longer available for future
	// calls).
	DisposeExecutor(ctx context.Context, in *DisposeExecutorRequest, opts ...grpc.CallOption) (*DisposeExecutorResponse, error)
}

type ExecutorGroupServer interface {
	// Returns a
	GetExecutor(context.Context, *GetExecutorRequest) (*GetExecutorResponse, error)
	// Creates a value in the executor and returns a reference to it that can be
	// supplied as an argument to other methods.
	CreateValue(context.Context, *CreateValueRequest) (*CreateValueResponse, error)
	// Creates a call in the executor and returns a reference to the result.
	CreateCall(context.Context, *CreateCallRequest) (*CreateCallResponse, error)
	// Creates a struct of values in the executor and returns a reference to it.
	CreateStruct(context.Context, *CreateStructRequest) (*CreateStructResponse, error)
	// Creates a selection from an executor value and returns a reference to it.
	CreateSelection(context.Context, *CreateSelectionRequest) (*CreateSelectionResponse, error)
	// Causes a value in the executor to get computed, and sends back the result.
	// WARNING: Unlike all other methods in this API, this may be a long-running
	// call (it will block until the value becomes available).
	Compute(context.Context, *ComputeRequest) (*ComputeResponse, error)
	// Causes one or more values in the executor to get disposed of (no longer
	// available for future calls).
	Dispose(context.Context, *DisposeRequest) (*DisposeResponse, error)
	// Causes an executor to be disposed of (no longer available for future
	// calls).
	DisposeExecutor(context.Context, *DisposeExecutorRequest) (*DisposeExecutorResponse, error)
	// contains filtered or unexported methods
}

type ExecutorId struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// contains filtered or unexported fields
}

type FederatedType struct {

	// A specification of placement that identifies the collective of participants
	// in a distributed system on which member components of this federated value
	// are hosted.
	//
	// If the federated type appears as a part of a functional type signature,
	// this placement will generally be defined using a PlacementLabel to bind it
	// to the type of the parameter, e.g., as below:
	//
	// federated_broadcast: T, p: placement -> T@p
	//
	// In the above "T@p" is a federated type, with label "p" (represented in the
	// type as a PlacementLabel) simply serving as a reference to the parameter
	// on the left.
	//
	// On the other hand, if a federated type appears on its own, not tied to the
	// placement of any function parameter, the placement specified here will be
	// a concrete placement literal (represented by a PlacementValue).
	Placement *PlacementSpec `protobuf:"bytes,1,opt,name=placement,proto3" json:"placement,omitempty"`
	// A bit that, if set, indicates that the member components of the federated
	// value are all equal (if not set, member components may vary). This
	// distinction is only meaningful for placements that represent collectives,
	// such as clients or intermediate aggregators. For placements that represent
	// centralized components (such as a central coordinator), this property is
	// trivially satisfied (and still documented by setting this bit to True).
	AllEqual bool `protobuf:"varint,2,opt,name=all_equal,json=allEqual,proto3" json:"all_equal,omitempty"`
	// The type of the local member components of the federated value, i.e., the
	// components that are locally hosted on each individual participant (member
	// of the collective determined by the "placement" above).
	Member *Type `protobuf:"bytes,3,opt,name=member,proto3" json:"member,omitempty"`
	// contains filtered or unexported fields
}

type FunctionType struct {
	Parameter *Type `protobuf:"bytes,1,opt,name=parameter,proto3" json:"parameter,omitempty"`
	Result    *Type `protobuf:"bytes,2,opt,name=result,proto3" json:"result,omitempty"`
	// contains filtered or unexported fields
}

type GetExecutorRequest struct {
	Cardinalities []*Cardinality `protobuf:"bytes,1,rep,name=cardinalities,proto3" json:"cardinalities,omitempty"`
	// contains filtered or unexported fields
}

type GetExecutorResponse struct {
	Executor *ExecutorId `protobuf:"bytes,1,opt,name=executor,proto3" json:"executor,omitempty"`
	// contains filtered or unexported fields
}

type Intrinsic struct {

	// The URI that uniquely identifies the intrinsic within the set of operators
	// built into the framework.
	Uri string `protobuf:"bytes,1,opt,name=uri,proto3" json:"uri,omitempty"`
	// contains filtered or unexported fields
}

type Lambda struct {

	// The name to use internally within this lambda to refer to the parameter.
	// The parameter is mandatory. The name defined here can be used internally
	// anywhere in the result computation, except if overridden in a nested
	// lambda, where it can be hidden by a parameter with a conflicting name.
	ParameterName string `protobuf:"bytes,1,opt,name=parameter_name,json=parameterName,proto3" json:"parameter_name,omitempty"`
	// A computation that represents the result of applying the lambda to the
	// parameter. The result may (almost always will) contain references to the
	// parameter defined above.
	Result *Computation `protobuf:"bytes,2,opt,name=result,proto3" json:"result,omitempty"`
	// contains filtered or unexported fields
}

type Placement struct {

	// The globally unique URI that defines a specific global placement instance.
	// For example, an URI might represent the global collective of all mobile
	// devices running a certain app, or it might represent the specific
	// well-known address of a central coordinator. The exact naming schemes and
	// interpretation of these URIs is TBD, and will be documented later.
	Uri string `protobuf:"bytes,1,opt,name=uri,proto3" json:"uri,omitempty"`
	// contains filtered or unexported fields
}

type PlacementLabel struct {

	// The label used to refer to this specific placement within a type signature.
	Label string `protobuf:"bytes,1,opt,name=label,proto3" json:"label,omitempty"`
	// contains filtered or unexported fields
}

type PlacementSpec struct {

	// Types that are assignable to Placement:
	//	*PlacementSpec_Label
	//	*PlacementSpec_Value
	Placement isPlacementSpec_Placement `protobuf_oneof:"placement"`
	// contains filtered or unexported fields
}

type PlacementSpec_Label struct {
	Label *PlacementLabel `protobuf:"bytes,1,opt,name=label,proto3,oneof"`
}

type PlacementSpec_Value struct {
	Value *Placement `protobuf:"bytes,2,opt,name=value,proto3,oneof"`
}

type PlacementType struct {

	// An optional label that can be used to refer to the specific instance of the
	// "placement" type represented by this entry in the type signature. If this
	// field is present in the PlacementType message, generally as a parameter in
	// a functional type signature, the label is associated with the specific
	// placement value supplied in that parameter, which allows it to be used to
	// specify a federated type hosted by the collective of participants
	// represented by this placement. For example, consider this type signature:
	//
	// federated_broadcast: T, p: placement -> T@p
	//
	// The type specification of the 2nd element of the broadcast argument Struct
	// would be PlacementType(instance_label=PlacementLabel(label='p')). Here, the
	// type of the second element is still simply "placement"; as noted above,
	// there is only one such built-in type to represent all sorts of collectives.
	// The presence of the label only associates 'p' with the value of the second
	// element of the parameter Struct. On the right side, the pecification of the
	// federated result type contains Placement(label=PlacementLabel(label='p')),
	// thus binding the placement of the result to the value in the argument. When
	// comparing types, the presence of this label is ignored.
	InstanceLabel *PlacementLabel `protobuf:"bytes,1,opt,name=instance_label,json=instanceLabel,proto3" json:"instance_label,omitempty"`
	// contains filtered or unexported fields
}

type Reference struct {
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

type Selection struct {

	// The source of selection, always required. This is a computation that
	// returns a Struct (possibly nested), from which to select an element
	// by name or by index.
	Source *Computation `protobuf:"bytes,1,opt,name=source,proto3" json:"source,omitempty"`
	// A specification of what to select from the context (Struct). Indexes,
	// when applied to Structs, are 0-based, i.e., "[0]" selects the first
	// element.
	Index int32 `protobuf:"varint,3,opt,name=index,proto3" json:"index,omitempty"`
	// contains filtered or unexported fields
}

type SequenceType struct {
	Element *Type `protobuf:"bytes,1,opt,name=element,proto3" json:"element,omitempty"`
	// contains filtered or unexported fields
}

type Struct struct {

	// The ordering of Struct elements is significant, and determines the type of
	// the value represented by the expression. The names are optional.
	Element []*Struct_Element `protobuf:"bytes,1,rep,name=element,proto3" json:"element,omitempty"`
	// contains filtered or unexported fields
}

type StructType struct {
	Element []*StructType_Element `protobuf:"bytes,1,rep,name=element,proto3" json:"element,omitempty"`
	// contains filtered or unexported fields
}

type StructType_Element struct {
	Name  string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Value *Type  `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type Struct_Element struct {
	Name  string       `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Value *Computation `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type TensorFlow struct {

	// A serialized representation of a TensorFlow graph to execute.
	//
	// Stores a tensorflow.GraphDef message.
	// Note: This representation may evolve, e.g., get replaced with a MetaGraph,
	// SavedModel, or a similar structure. Dependencies on the exact form of the
	// graph encoding used here should be kept to minimum, and proxied by wrapper
	// libraries for composing computations in python/core/impl/.
	//
	// TODO(b/117428091): Update this representation based on the emerging TF 2.0
	// serialization standards as needed if/when they meet the constraints of the
	// target production environments, and provided that they don't introduce
	// additional complexity.
	GraphDef *anypb.Any `protobuf:"bytes,1,opt,name=graph_def,json=graphDef,proto3" json:"graph_def,omitempty"`
	// String name of an initialization op to run on the graph before fetching
	// results. This op is intended only to be used for running tf.Variable
	// initializers.
	InitializeOp string `protobuf:"bytes,4,opt,name=initialize_op,json=initializeOp,proto3" json:"initialize_op,omitempty"`
	// String name of a tensor which may be fed a unique identifier token for the
	// current session. This allows TensorFlow custom ops to refer to
	// session-global values created by the runner of the current session.
	SessionTokenTensorName string `` /* 131-byte string literal not displayed */
	// A pair of bindings for the parameter and the result. The parameter binding
	// can be omitted if the computation does not declare a parameter. The result
	// binding is mandatory, as all TensorFlow computations must declare results.
	Parameter *TensorFlow_Binding  `protobuf:"bytes,2,opt,name=parameter,proto3" json:"parameter,omitempty"`
	Result    *TensorFlow_Binding  `protobuf:"bytes,3,opt,name=result,proto3" json:"result,omitempty"`
	CacheKey  *TensorFlow_CacheKey `protobuf:"bytes,5,opt,name=cache_key,json=cacheKey,proto3" json:"cache_key,omitempty"`
	// contains filtered or unexported fields
}

type TensorFlow_Binding struct {

	// Types that are assignable to Binding:
	//	*TensorFlow_Binding_Struct
	//	*TensorFlow_Binding_Tensor
	//	*TensorFlow_Binding_Sequence
	Binding isTensorFlow_Binding_Binding `protobuf_oneof:"binding"`
	// contains filtered or unexported fields
}

type TensorFlow_Binding_Sequence struct {
	// A binding associated with a sequence. Associates the sequence with a
	// part of the TensorFlow graph that will represent a data set iterator,
	// next element, or an equivalent iterator-like structure.
	Sequence *TensorFlow_SequenceBinding `protobuf:"bytes,3,opt,name=sequence,proto3,oneof"`
}

type TensorFlow_Binding_Struct struct {
	// A binding associated with a struct in the type signature. Specifies an
	// individual binding for each element of the struct.
	Struct *TensorFlow_StructBinding `protobuf:"bytes,1,opt,name=struct,proto3,oneof"`
}

type TensorFlow_Binding_Tensor struct {
	// A binding associated with a (logical) tensor in the type signature.
	// Associates that tensor to one or more (concrete) tensors in the graph.
	Tensor *TensorFlow_TensorBinding `protobuf:"bytes,2,opt,name=tensor,proto3,oneof"`
}

type TensorFlow_CacheKey struct {
	Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	// contains filtered or unexported fields
}

type TensorFlow_SequenceBinding struct {

	// Types that are assignable to Binding:
	//	*TensorFlow_SequenceBinding_VariantTensorName
	//	*TensorFlow_SequenceBinding_GraphDefTensorName
	Binding isTensorFlow_SequenceBinding_Binding `protobuf_oneof:"binding"`
	// contains filtered or unexported fields
}

type TensorFlow_SequenceBinding_GraphDefTensorName struct {
	// The name of the string tensor that represents the data set created
	// using `tf.raw_ops.DatasetFromGraph`.
	GraphDefTensorName string `protobuf:"bytes,3,opt,name=graph_def_tensor_name,json=graphDefTensorName,proto3,oneof"`
}

type TensorFlow_SequenceBinding_VariantTensorName struct {
	// The name of the variant tensor that represents the data set created
	// using `tf.data.experimental.from_variant`.
	VariantTensorName string `protobuf:"bytes,2,opt,name=variant_tensor_name,json=variantTensorName,proto3,oneof"`
}

type TensorFlow_StructBinding struct {

	// Bindings for elements of the Struct. The number of elements in this field
	// must be equal to the number of Struct elements declared in the type
	// signature, with the k-th binding declared here corresponding to the k-th
	// Struct element in the type signature. The element names are omitted since
	// they are redundant (correspondence is established by element order).
	Element []*TensorFlow_Binding `protobuf:"bytes,1,rep,name=element,proto3" json:"element,omitempty"`
	// contains filtered or unexported fields
}

type TensorFlow_TensorBinding struct {

	// Types that are assignable to Binding:
	//	*TensorFlow_TensorBinding_TensorName
	Binding isTensorFlow_TensorBinding_Binding `protobuf_oneof:"binding"`
	// contains filtered or unexported fields
}

type TensorFlow_TensorBinding_TensorName struct {
	// The name of a dense tensor in a TensorFlow graph that corresponds to a
	// single tensor component in the type signature.
	TensorName string `protobuf:"bytes,1,opt,name=tensor_name,json=tensorName,proto3,oneof"`
}

type TensorType struct {
	Dtype TensorType_DataType `protobuf:"varint,1,opt,name=dtype,proto3,enum=tensorflow_federated.v0.TensorType_DataType" json:"dtype,omitempty"`
	// The sizes of each dimension of the tensor.
	//
	// Undefined dimensions are allowed and represented by -1. Defined and
	// undefined dimensions are to be considered distinct for type checking
	// purposes.
	Dims []int64 `protobuf:"varint,2,rep,packed,name=dims,proto3" json:"dims,omitempty"`
	// True iff the number of dimensions is unknown.
	//
	// If `dims` is unset:
	// - `unknown_rank` == True corresponds to tf.TensorShape(None)
	// - `unknown_rank` == False corresponds to tf.TensorShape([])
	UnknownRank bool `protobuf:"varint,3,opt,name=unknown_rank,json=unknownRank,proto3" json:"unknown_rank,omitempty"`
	// contains filtered or unexported fields
}

type TensorType_DataType int32

type Type struct {

	// Types that are assignable to Type:
	//	*Type_Function
	//	*Type_Struct
	//	*Type_Sequence
	//	*Type_Tensor
	//	*Type_Abstract
	//	*Type_Placement
	//	*Type_Federated
	Type isType_Type `protobuf_oneof:"type"`
	// contains filtered or unexported fields
}

type Type_Abstract struct {
	Abstract *AbstractType `protobuf:"bytes,5,opt,name=abstract,proto3,oneof"`
}

type Type_Federated struct {
	Federated *FederatedType `protobuf:"bytes,7,opt,name=federated,proto3,oneof"`
}

type Type_Function struct {
	Function *FunctionType `protobuf:"bytes,1,opt,name=function,proto3,oneof"`
}

type Type_Placement struct {
	Placement *PlacementType `protobuf:"bytes,6,opt,name=placement,proto3,oneof"`
}

type Type_Sequence struct {
	Sequence *SequenceType `protobuf:"bytes,3,opt,name=sequence,proto3,oneof"`
}

type Type_Struct struct {
	Struct *StructType `protobuf:"bytes,2,opt,name=struct,proto3,oneof"`
}

type Type_Tensor struct {
	Tensor *TensorType `protobuf:"bytes,4,opt,name=tensor,proto3,oneof"`
}

type UnimplementedExecutorGroupServer struct {
}

type UnsafeExecutorGroupServer interface {
	// contains filtered or unexported methods
}

type Value struct {

	// Types that are assignable to Value:
	//	*Value_Tensor
	//	*Value_Computation
	//	*Value_Struct_
	//	*Value_Sequence_
	//	*Value_Federated_
	Value isValue_Value `protobuf_oneof:"value"`
	// contains filtered or unexported fields
}

type ValueRef struct {

	// The identifier should consist of printable ASCII characters for the sake
	// of debuggability, ideally alphanumeric. The format of the identifier may
	// depend on the type of the executor.
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// contains filtered or unexported fields
}

type Value_Computation struct {
	// A serialized TFF computation; this is the canonical (and currently only)
	// way to pass any functional constructs, but the computation included here
	// does not necessarily have to be of a functional type.
	Computation *Computation `protobuf:"bytes,2,opt,name=computation,proto3,oneof"`
}

type Value_Federated struct {

	// The type of the federated value.
	Type *FederatedType `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	// The member constituents, one per participant in the collective defined
	// by this value's placement within the executor.
	Value []*Value `protobuf:"bytes,2,rep,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type Value_Federated_ struct {
	// A value of a federated type.
	Federated *Value_Federated `protobuf:"bytes,5,opt,name=federated,proto3,oneof"`
}

type Value_Sequence struct {

	// The serialized representation of this sequence.
	//
	// Types that are assignable to Value:
	//	*Value_Sequence_ZippedSavedModel
	//	*Value_Sequence_SerializedGraphDef
	Value isValue_Sequence_Value `protobuf_oneof:"value"`
	// The TensorFlow Federated `Type` of the elements in this
	// sequence.
	ElementType *Type `protobuf:"bytes,2,opt,name=element_type,json=elementType,proto3" json:"element_type,omitempty"`
	// contains filtered or unexported fields
}

type Value_Sequence_ struct {
	// A sequence of values.
	Sequence *Value_Sequence `protobuf:"bytes,4,opt,name=sequence,proto3,oneof"`
}

type Value_Sequence_SerializedGraphDef struct {
	// The result of the `DatasetToGraphV2` op called on a Dataset's variant
	// tensor.
	SerializedGraphDef []byte `protobuf:"bytes,3,opt,name=serialized_graph_def,json=serializedGraphDef,proto3,oneof"`
}

type Value_Sequence_ZippedSavedModel struct {
	// The bytes of a zip file over the files produced by a
	// `tf.saved_model.save()` operation, intended to be used with a
	// corresponding `tf.saved_model.load()` op.
	//
	// Deprecated: Do not use.
	ZippedSavedModel []byte `protobuf:"bytes,1,opt,name=zipped_saved_model,json=zippedSavedModel,proto3,oneof"`
}

type Value_Struct struct {
	Element []*Value_Struct_Element `protobuf:"bytes,1,rep,name=element,proto3" json:"element,omitempty"`
	// contains filtered or unexported fields
}

type Value_Struct_ struct {
	// A struct of values.
	Struct *Value_Struct `protobuf:"bytes,3,opt,name=struct,proto3,oneof"`
}

type Value_Struct_Element struct {
	Name  string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Value *Value `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type Value_Tensor struct {
	// A serialized tensor content as an instance of `tensorflow.TensorProto`,
	// as defined in `tensorflow/core/framework/tensor.proto`.
	Tensor *anypb.Any `protobuf:"bytes,1,opt,name=tensor,proto3,oneof"`
}

type Xla struct {

	// A serialized representation of XLA code to execute.
	//
	// Stores an `HloModuleProto` message, as defined in the TensorFlow repo in
	// the file "tensorflow/compiler/xla/service/hlo.proto" in the main branch.
	//
	// It is recommended, albeit not required that the entry computation in this
	// module accepts its parameters as a single tuple.
	//
	// NOTE: As it is experimental-only, this representation may evolve, possibly
	// in a manner that is backwards-incompatible. Make sure not to depend on the
	// current form of this representation, and not to persist it in places where
	// subsequent changes could cause breakages.
	HloModule *anypb.Any `protobuf:"bytes,1,opt,name=hlo_module,json=hloModule,proto3" json:"hlo_module,omitempty"`
	// A pair of bindings for the parameter and the result. The parameter binding
	// can be omitted if the computation does not declare a parameter. The result
	// binding is mandatory, as all XLA computations must declare results.
	Parameter *Xla_Binding `protobuf:"bytes,2,opt,name=parameter,proto3" json:"parameter,omitempty"`
	Result    *Xla_Binding `protobuf:"bytes,3,opt,name=result,proto3" json:"result,omitempty"`
	// contains filtered or unexported fields
}

type Xla_Binding struct {

	// Types that are assignable to Binding:
	//	*Xla_Binding_Struct
	//	*Xla_Binding_Tensor
	Binding isXla_Binding_Binding `protobuf_oneof:"binding"`
	// contains filtered or unexported fields
}

type Xla_Binding_Struct struct {
	Struct *Xla_StructBinding `protobuf:"bytes,1,opt,name=struct,proto3,oneof"`
}

type Xla_Binding_Tensor struct {
	Tensor *Xla_TensorBinding `protobuf:"bytes,2,opt,name=tensor,proto3,oneof"`
}

type Xla_StructBinding struct {

	// Bindings for elements of the struct. The number of elements in this field
	// must be equal to the number of struct elements declared in the type
	// signature, with the k-th binding declared here corresponding to the k-th
	// struct element in the type signature. The element names are omitted since
	// they are redundant (correspondence is established by element order).
	Element []*Xla_Binding `protobuf:"bytes,1,rep,name=element,proto3" json:"element,omitempty"`
	// contains filtered or unexported fields
}

type Xla_TensorBinding struct {

	// Types that are assignable to Binding:
	//	*Xla_TensorBinding_Index
	Binding isXla_TensorBinding_Binding `protobuf_oneof:"binding"`
	// contains filtered or unexported fields
}

type Xla_TensorBinding_Index struct {
	// The 0-based index of this tensor in (the flattened form of) either the
	// parameter or result tuple for the entry computation of the HLO module,
	// i.e., the `HloComputationProto` with the id matching the module's
	// `entry_computation_id`.
	//
	// The order of indexes associated with the result tensors is defined by
	// the order in which tensors appear in the DFS traversal of the root
	// instruction in the computation (which can be a tensor, or a possibly
	// recursively nested tuple). For example, if the XLA computation returns
	// a nested tuple ((int32, int32), int32), the indexes of the tensors in
	// the result are ((0, 1), 2), accordingly.
	//
	// The order of indexes for parameter tensors is defined likewise. In the
	// case of multiple arguments, tensor indexes are determined by traversing
	// arguments in the order in which they appear on the parameter list (the
	// order of `parameter_number` in the `HloInstructionProto`s.
	// For example, if the computation takes 2 arguments, the first of which
	// is a 2-tuple of tensors, and the second of which is a tensor, the
	// indexes identifying the individual portions of the argument list would
	// be (0, 1), 2, i.e., 0 would refer to the first tuple element of the
	// first parameter, etc.
	Index int32 `protobuf:"varint,1,opt,name=index,proto3,oneof"`
}