plan

type Block struct {

	// Label is the name / field-name of this Block.
	// Any UTF8 string is available and only 0x00 (NUL) is disallowed (such as in Go).
	Label string `protobuf:"bytes,1,opt,name=Label,proto3" json:"Label,omitempty"`
	// ContentType self-describes the nature of a Block's data and what form it takes.
	// Anyone handed this Block instance can accurately interpret / process / deserialize its content.
	// In effect, this field is a MIME type or more generally any multicodec pathname (e.g. "text/html", "image/png", "audio/mp3")
	ContentType string `protobuf:"bytes,2,opt,name=ContentType,proto3" json:"ContentType,omitempty"`
	// Codec supplements the role of ContentType or can be used for efficiency and ease.
	// For example, 100,000 Blocks could all repeat a ContentType string over and over, ar an inline int can be used instead.
	// For example, see: https://github.com/multiformats/multicodec
	Codec uint32 `protobuf:"varint,3,opt,name=Codec,proto3" json:"Codec,omitempty"`
	// Timestamps associated with this Block's content (in seconds UTC).
	TimeCreated  int64 `protobuf:"varint,4,opt,name=TimeCreated,proto3" json:"TimeCreated,omitempty"`
	TimeModified int64 `protobuf:"varint,5,opt,name=TimeModified,proto3" json:"TimeModified,omitempty"`
	// Subs are optionally nested sub items that can be interpreted or employed in any way a client or protocol sees fit.
	Subs []*Block `protobuf:"bytes,10,rep,name=Subs,proto3" json:"Subs,omitempty"`
	// Content/payload data -- structured in accordance with Block.ContentType and/or Block.Codec.
	// The variety of data-types here allow an architect to package raw data free of overhead penalties, courtesy of protobufs.
	DataVeci []int64   `protobuf:"varint,20,rep,packed,name=DataVeci,proto3" json:"DataVeci,omitempty"`
	DataVecf []float32 `protobuf:"fixed32,21,rep,packed,name=DataVecf,proto3" json:"DataVecf,omitempty"`
	DataVecd []float64 `protobuf:"fixed64,22,rep,packed,name=DataVecd,proto3" json:"DataVecd,omitempty"`
	DataVecs []string  `protobuf:"bytes,23,rep,name=DataVecs,proto3" json:"DataVecs,omitempty"`
	DataARGB uint32    `protobuf:"fixed32,30,opt,name=DataARGB,proto3" json:"DataARGB,omitempty"`
	DataBuf  []byte    `protobuf:"bytes,31,opt,name=DataBuf,proto3" json:"DataBuf,omitempty"`
	DataStr  string    `protobuf:"bytes,32,opt,name=DataStr,proto3" json:"DataStr,omitempty"`
	DataInt  int64     `protobuf:"varint,33,opt,name=DataInt,proto3" json:"DataInt,omitempty"`
	DataX1   float32   `protobuf:"fixed32,41,opt,name=DataX1,proto3" json:"DataX1,omitempty"`
	DataX2   float32   `protobuf:"fixed32,42,opt,name=DataX2,proto3" json:"DataX2,omitempty"`
	DataX3   float32   `protobuf:"fixed32,43,opt,name=DataX3,proto3" json:"DataX3,omitempty"`
	// contains filtered or unexported fields
}

type ChangeUserPermsReq struct {
	ChURI              string `protobuf:"bytes,1,opt,name=ChURI,proto3" json:"ChURI,omitempty"`
	Address            string `protobuf:"bytes,2,opt,name=Address,proto3" json:"Address,omitempty"`
	WriteKeypathsRegex string `protobuf:"bytes,3,opt,name=WriteKeypathsRegex,proto3" json:"WriteKeypathsRegex,omitempty"`
	CanWrite           bool   `protobuf:"varint,4,opt,name=CanWrite,proto3" json:"CanWrite,omitempty"`
	// contains filtered or unexported fields
}

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

type FetchFlags int32

type FilterFlags int32

type GRPCServer struct {
	*ctx.Context
	// contains filtered or unexported fields
}

type Node struct {

	// ID is required and uniquely identifies a node.
	// An ID can be any UTF8 string longer than 1 character, BUT CANNOT contain a forward slash ('/') or contain any whitespace characters.
	ID string `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`
	// Layer, if non-nil, means this node can contain other nodes -- it is also dubbed a "node space"
	// For nodes that have this Layer as the parent, their coordinates are relative to the coordinate space of this Node.
	// Nested NodeLayers allow Node placements to occur with pluggable transformations.
	Layer *NodeLayer `protobuf:"bytes,2,opt,name=Layer,proto3" json:"Layer,omitempty"`
	// Tags is a collection of UTF8 identifying strings delimited by a comma (',').
	// This offers a flexible and lightweight system to filter hits during NodeScan()
	Tags string `protobuf:"bytes,4,opt,name=Tags,proto3" json:"Tags,omitempty"`
	// LastModified is a timestamp of when this node was last altered (in UTC seconds).
	// By default, this field is auto-updated during NodePut().
	LastModified int64 `protobuf:"varint,7,opt,name=LastModified,proto3" json:"LastModified,omitempty"`
	// Optional values that can express commonly needed fields or allow this Node to be self-describing.
	TypeID string `protobuf:"bytes,10,opt,name=TypeID,proto3" json:"TypeID,omitempty"`
	Glyph  string `protobuf:"bytes,11,opt,name=Glyph,proto3" json:"Glyph,omitempty"`
	Name   string `protobuf:"bytes,12,opt,name=Name,proto3" json:"Name,omitempty"`
	Value  string `protobuf:"bytes,13,opt,name=Value,proto3" json:"Value,omitempty"`
	// X1,.. are coordinates expressed in the parent's coordinate space.
	// Shoutout to the 3 domains that reflect all theoretical completeness: alpha (finite), omega (unending), and the inaccessible cardinal(s).
	// Special thanks to Michael at Vsauce: https://www.youtube.com/watch?v=SrU9YDoXE88
	X1 float64 `protobuf:"fixed64,21,opt,name=X1,proto3" json:"X1,omitempty"`
	X2 float64 `protobuf:"fixed64,22,opt,name=X2,proto3" json:"X2,omitempty"`
	X3 float64 `protobuf:"fixed64,23,opt,name=X3,proto3" json:"X3,omitempty"`
	// Transform means this Node and its sub nodes should be scaled by [0] (or [0,1,2]) and rotated according to thw quaternion stored in [1,2,3,4] (or [3,4,5,6])
	// If omitted, implied scale is 1 and there no rotation is applied.
	Transform []float32 `protobuf:"fixed32,25,rep,packed,name=Transform,proto3" json:"Transform,omitempty"`
	// T is a time offset expressed in seconds.
	// A Node's parent layer defines how T=0 maps onto UTC, offering greater of precision (where precision would otherwise be "burned up" by expressing large time value).
	T float64 `protobuf:"fixed64,28,opt,name=T,proto3" json:"T,omitempty"`
	// TSpan is a time duration or period expressed in seconds.
	TSpan float64 `protobuf:"fixed64,29,opt,name=TSpan,proto3" json:"TSpan,omitempty"`
	// Links are URIs to other linked nodes.
	// [<ChURI>[<ParentLayerID>/]]<NodeID>
	Links []string `protobuf:"bytes,40,rep,name=Links,proto3" json:"Links,omitempty"`
	// Nodes are corresponding elements of .Links (above) resolved/expanded.
	// This is only used for a server to return this.Links in their resolved form.
	// See use of LinksFetchFlags in NodeScanReq.
	LinksResolved []*Node `protobuf:"bytes,41,rep,name=LinksResolved,proto3" json:"LinksResolved,omitempty"`
	// Block is any client data payload (and is generally not accessed by redwood).
	// When non-nil, it is assumed to be the output of this.BlockRaw.Unmarshal()
	Block *Block `protobuf:"bytes,50,opt,name=Block,proto3" json:"Block,omitempty"`
	// BlockRaw is the protobufs serialization of this.Block.
	// When non-nil, it is assumed to be the output of this.Block.Marshal()
	BlockRaw []byte `protobuf:"bytes,51,opt,name=BlockRaw,proto3" json:"BlockRaw,omitempty"`
	// ParentID is the ID of the Node layer that this Node entry appears in (and whose fields are transformed through that layer).
	// If this field is empty or nil, the identity/default layer ID and is assumed (and is denoted as '!')
	// This field is NOT stored directly (as it is exists implicitly):
	//      - when set by a server (by request via FetchFlags), it is recovered from internal server db info.
	//      - when set by a client, the client is specifying which parent this node resides in.
	ParentID string `protobuf:"bytes,60,opt,name=ParentID,proto3" json:"ParentID,omitempty"`
	// ChURI is the channel state URI for this node.
	// This is only used during RPC.ChannelGenesis() and RPC.PutNode() to express a destination ChURI.
	ChURI string `protobuf:"bytes,61,opt,name=ChURI,proto3" json:"ChURI,omitempty"`
	// contains filtered or unexported fields
}

type NodeGetReq struct {
	ChURI    string `protobuf:"bytes,1,opt,name=ChURI,proto3" json:"ChURI,omitempty"`
	ParentID string `protobuf:"bytes,2,opt,name=ParentID,proto3" json:"ParentID,omitempty"`
	NodeID   string `protobuf:"bytes,3,opt,name=NodeID,proto3" json:"NodeID,omitempty"`
	// NodeFetchFlags specifies which fields are loaded and returned for each Node scan match/hit returned by NodeScan().
	NodeFetchFlags FetchFlags `protobuf:"varint,40,opt,name=NodeFetchFlags,proto3,enum=plan.FetchFlags" json:"NodeFetchFlags,omitempty"`
	// LinksFetchFlags specifies which fields are loaded and returned for linked nodes of each Node hit returned by a NodeScan().
	LinksFetchFlags FetchFlags `protobuf:"varint,41,opt,name=LinksFetchFlags,proto3,enum=plan.FetchFlags" json:"LinksFetchFlags,omitempty"`
	// contains filtered or unexported fields
}

type NodeLayer struct {

	// T0AsUTC expresses the UTC time index (in seconds) of a Node at T = 0.
	// This means a NodeLayer can be anchored to any point on the UTC timeline with double precision accuracy.
	// This allows a time series of nodes to reside at any conceivable time scale: the planck scale or the timescale of the universe, 14 billion years.
	T0AsUTC float64 `protobuf:"fixed64,5,opt,name=T0AsUTC,proto3" json:"T0AsUTC,omitempty"`
	// SpaceType specifies the implicit geometry baked into coordinates of nodes in this layer.
	// It designates a particular of 1D, 2D, 3D topography or coordinate system.
	// e.g. "cartesian/xyz", "cylindrical/angle-r-z", "spherical/r-theta-phi", "geospace-earth/lat-long-alt"
	SpaceType string `protobuf:"bytes,10,opt,name=SpaceType,proto3" json:"SpaceType,omitempty"`
	// X1UnitType is a unit MIME type descriptor
	// e.g. "angle/degrees", "distance/meters", "mass/kilograms", "temperature/celsius", "charge/amp-hours", "energy/kw-hours", "wisdom/years"
	X1UnitType string `protobuf:"bytes,31,opt,name=X1UnitType,proto3" json:"X1UnitType,omitempty"`
	X2UnitType string `protobuf:"bytes,32,opt,name=X2UnitType,proto3" json:"X2UnitType,omitempty"`
	X3UnitType string `protobuf:"bytes,33,opt,name=X3UnitType,proto3" json:"X3UnitType,omitempty"`
	// contains filtered or unexported fields
}

type NodePutReq struct {

	// Nodes is a list of Nodes to be put (in order).
	// NodePut() will first merge these Nodes in the order they appear (or will no-op if this list is nil or empty).
	// All values of Node.ChURI must be equal or an error is returned (excluding empty/omitted URIs which denotes deferring to another Node.ChURI)
	Nodes []*Node `protobuf:"bytes,5,rep,name=Nodes,proto3" json:"Nodes,omitempty"`
	// Node is a node to be put.
	// NodePut() will merge this Node (or will no-op if this Node is nil).
	// This field is offered as convenience and is equivalent to putting this node at the end of .Nodes[]
	Node *Node `protobuf:"bytes,6,opt,name=Node,proto3" json:"Node,omitempty"`
	// contains filtered or unexported fields
}

type NodeScanReq struct {
	ChURI string `protobuf:"bytes,1,opt,name=ChURI,proto3" json:"ChURI,omitempty"`
	// Note that "!" is used to denote ChURI's default (root) node ID.
	// FUTURE: should this instead just be any valid parent node ID pathname?
	RegexParentID string `protobuf:"bytes,3,opt,name=RegexParentID,proto3" json:"RegexParentID,omitempty"`
	// Filters to apply to each node candidate
	RegexNodeID string `protobuf:"bytes,10,opt,name=RegexNodeID,proto3" json:"RegexNodeID,omitempty"`
	RegexName   string `protobuf:"bytes,11,opt,name=RegexName,proto3" json:"RegexName,omitempty"`
	RegexTags   string `protobuf:"bytes,12,opt,name=RegexTags,proto3" json:"RegexTags,omitempty"`
	RegexTypeID string `protobuf:"bytes,13,opt,name=RegexTypeID,proto3" json:"RegexTypeID,omitempty"`
	// FilterFlags further selects which Nodes are eligible to be scan hits.
	FilterFlags FilterFlags `protobuf:"varint,14,opt,name=FilterFlags,proto3,enum=plan.FilterFlags" json:"FilterFlags,omitempty"`
	// Subscribe specifies if this scan should remain open and await additional hits that may appear as state is updated.
	Subscribe bool `protobuf:"varint,20,opt,name=Subscribe,proto3" json:"Subscribe,omitempty"`
	// Min/max time search params (no search if TMax > TMin)
	TMin float64 `protobuf:"fixed64,30,opt,name=TMin,proto3" json:"TMin,omitempty"`
	TMax float64 `protobuf:"fixed64,31,opt,name=TMax,proto3" json:"TMax,omitempty"`
	// See NodeGetReq
	NodeFetchFlags  FetchFlags `protobuf:"varint,40,opt,name=NodeFetchFlags,proto3,enum=plan.FetchFlags" json:"NodeFetchFlags,omitempty"`
	LinksFetchFlags FetchFlags `protobuf:"varint,41,opt,name=LinksFetchFlags,proto3,enum=plan.FetchFlags" json:"LinksFetchFlags,omitempty"`
	// contains filtered or unexported fields
}

type RPCClient interface {
	ChannelGenesis(ctx context.Context, in *ChannelGenesisReq, opts ...grpc.CallOption) (*TxInfo, error)
	ChangeUserPerms(ctx context.Context, in *ChangeUserPermsReq, opts ...grpc.CallOption) (*TxInfo, error)
	// NodeGet returns the node with the given ChURI, parent node ID, and node ID.
	// Assuming the given ChURI is valid for reading, an empty Node (Node.ID == nil) is returned if the parent or node ID does not exist.
	NodeGet(ctx context.Context, in *NodeGetReq, opts ...grpc.CallOption) (*Node, error)
	NodeScan(ctx context.Context, in *NodeScanReq, opts ...grpc.CallOption) (RPC_NodeScanClient, error)
	NodePut(ctx context.Context, in *NodePutReq, opts ...grpc.CallOption) (*TxInfo, error)
}

type RPCServer interface {
	ChannelGenesis(context.Context, *ChannelGenesisReq) (*TxInfo, error)
	ChangeUserPerms(context.Context, *ChangeUserPermsReq) (*TxInfo, error)
	// NodeGet returns the node with the given ChURI, parent node ID, and node ID.
	// Assuming the given ChURI is valid for reading, an empty Node (Node.ID == nil) is returned if the parent or node ID does not exist.
	NodeGet(context.Context, *NodeGetReq) (*Node, error)
	NodeScan(*NodeScanReq, RPC_NodeScanServer) error
	NodePut(context.Context, *NodePutReq) (*TxInfo, error)
}

type RPC_NodeScanClient interface {
	Recv() (*Node, error)
	grpc.ClientStream
}

type RPC_NodeScanServer interface {
	Send(*Node) error
	grpc.ServerStream
}

type TxInfo struct {
	StateURI string `protobuf:"bytes,1,opt,name=StateURI,proto3" json:"StateURI,omitempty"`
	TxID     []byte `protobuf:"bytes,2,opt,name=TxID,proto3" json:"TxID,omitempty"`
	// contains filtered or unexported fields
}

type UnimplementedRPCServer struct {
}