repo

type ChKey []byte

type ChReq struct {
	// ReqOp requests that the given op to be execute on ChReq.Entries
	ReqOp ChReqOp `protobuf:"varint,1,opt,name=ReqOp,proto3,enum=repo.ChReqOp" json:"ReqOp,omitempty"`
	// ReqID is a client-assigned ID that allows the client and server to reference this ChReq in the future.
	// Node.ReqComplete & ReqDiscarded is how the server signals when this request is considered closed/complete.
	ReqID int32 `protobuf:"varint,2,opt,name=ReqID,proto3" json:"ReqID,omitempty"`
	// ChURI identifies the channel URI that this ChReq is requesting to access.
	// Channel URIs take the form of "<DomainName>[/<ChID>]".
	ChURI string `protobuf:"bytes,3,opt,name=ChURI,proto3" json:"ChURI,omitempty"`
	// ChStateURI expresses the channel URI that this op applies to.
	// If not set, it will be auto-assigned by parsing ChReq.ChURI.
	ChStateURI *ChStateURI `protobuf:"bytes,4,opt,name=ChStateURI,proto3" json:"ChStateURI,omitempty"`
	// When ReqOp == ChReqOp.Auto, one of these ops is to be executed.
	// It's an error to set more than one of these.
	GetOp                *GetOp   `protobuf:"bytes,10,opt,name=GetOp,proto3" json:"GetOp,omitempty"`
	TxOp                 *TxOp    `protobuf:"bytes,11,opt,name=TxOp,proto3" json:"TxOp,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type ChReqOp int32

type ChStateURI struct {
	// DomainName specifies the parent community/context name of the given channel ID.  Domain names are how
	// channel syndication properties, storage quotas, and prioritization are possible at the vault level.
	DomainName string `protobuf:"bytes,1,opt,name=DomainName,proto3" json:"DomainName,omitempty"`
	// ChID_TID specifies a channel's TID for a given domain name.
	// If this is not set, then the channel ID is considered to be non-binary and is contained in ChID.
	ChID_TID []byte `protobuf:"bytes,2,opt,name=ChID_TID,json=ChIDTID,proto3" json:"ChID_TID,omitempty"`
	// ChID is a UTF8 string name of this channel.
	// IF both ChID and ChID_TID are set, ChID is assumed to contain the base32 representation of ChID_TID.
	ChID string `protobuf:"bytes,3,opt,name=ChID,proto3" json:"ChID,omitempty"`
	// StateURI is a token that expresses a specific channel state.
	// If this is not set, the latest state of the channel is implied.
	// By convention this is a POSIX-style pathname in the form "<StateContextID>[/<SubStateID>]*"
	StateURI             string   `protobuf:"bytes,4,opt,name=StateURI,proto3" json:"StateURI,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type ChSub interface {
	ctx.Ctx

	Outbox() <-chan *Node
	Close()
}

type Const int32

type Domain interface {
	ctx.Ctx

	// Places this Domain on service
	Start() error

	// OpenChSub services a channel Get request.
	OpenChSub(chReq *ChReq) (ChSub, error)

	// SubmitTx takes ownership of the given tx and inserts it into the Host pipeline to be validated and merged.
	// If the given Tx is retained, it should be treated as read-only at this point onward.
	SubmitTx(tx *Tx) error

	// DomainName uniquely identifies this Domain
	DomainName() string
}

type EnclaveAccess struct {
	// Specifies the key pathname for this operation.
	Keypath string `protobuf:"bytes,1,opt,name=Keypath,proto3" json:"Keypath,omitempty"`
	// This will evolve in time, but in general, the client authenticates by submitting a hash of biometric-based input.
	// (e.g. pin, password, key-fob, bio-fingerprints) and a token from the previous session.
	// From this, a symmetric key is (re)created and used to access the member's primary key hive (for the given Keypath)
	Passhash             []byte   `protobuf:"bytes,5,opt,name=Passhash,proto3" json:"Passhash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type ErrCode int32

type GetOp struct {
	// Keypath and Scope together imply which entries are returned.
	Keypath string       `protobuf:"bytes,2,opt,name=Keypath,proto3" json:"Keypath,omitempty"`
	Scope   KeypathScope `protobuf:"varint,3,opt,name=Scope,proto3,enum=repo.KeypathScope" json:"Scope,omitempty"`
	// MaintainSync causes the ChReq to remain open and receive state updates for qualifying keypaths via ChSyncSuspend/ChSyncResume
	MaintainSync         bool     `protobuf:"varint,9,opt,name=MaintainSync,proto3" json:"MaintainSync,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

type Host interface {
	ctx.Ctx

	Domain

	// TODO: see comments in RepoServiceSession()
	NewSession() MemberSession
}

type HostParams struct {
	DomainName string
	BasePath   string
}

type KeypathScope int32

type LID uint32

type MemberSession interface {

	// ExpandAccess enables access into a secure enclave (for key direct or indirect access).
	// Currently, this is simply a master key that unlocks a key hive so that the user associated with this session can sign newly authored txns and decrypt private traffic.
	// In the future, these are paramters that connect (and drive) a physical keyfob to prompt the user to authenticate (via physical interaction or biometric input).
	ExpandAccess(access *EnclaveAccess) error

	// Accesses the currently set of activated enclaves and attempts to sign a newly authored transaction
	EncodeToTxAndSign(txOp *TxOp) (*Tx, error)
}

type Node struct {
	// Op tells the client with this channel open that kind of Node this is.
	Op NodeOp `protobuf:"varint,1,opt,name=Op,proto3,enum=repo.NodeOp" json:"Op,omitempty"`
	// ReqID references the originating ChReq that this Node is in response to.
	ReqID int32 `protobuf:"varint,2,opt,name=ReqID,proto3" json:"ReqID,omitempty"`
	// Keypath is a POSIX-style pathname of this channel entry (for safety, "/" specifies the root path, not "").
	// Each path component in a valid Keypath must have a length of at least 2.
	Keypath string `protobuf:"bytes,5,opt,name=Keypath,proto3" json:"Keypath,omitempty"`
	// RevID is the timestamp when this entry was submitted to the host channel in UTC seconds (where one sec is 2^16 ticks)
	RevID int64 `protobuf:"varint,10,opt,name=RevID,proto3" json:"RevID,omitempty"`
	// ParentRevID identifies the RevID of the Node instance that this node is replacing.
	// If this is 0, a Node at this keypath did not exist when this Node was submitted.
	ParentRevID int64 `protobuf:"varint,11,opt,name=ParentRevID,proto3" json:"ParentRevID,omitempty"`
	// TypeID is a "multi-codec" style (POSIX-style type pathname) that self-describes this Node and the information within it.
	TypeID string `protobuf:"bytes,15,opt,name=TypeID,proto3" json:"TypeID,omitempty"`
	// GlyphURI is a loose analog to the conventional use of "icon" and refer to a unit-sized graphic or volume.
	// Glyph URIs can allow the encoding of arbitrary parameters (such as color), allowing variants to be offered at no cost.
	// A given glyph URI often has both a 2D ("sprite") and 3D object form and is chosen based on where it's instanced.
	GlyphURI  string        `protobuf:"bytes,20,opt,name=GlyphURI,proto3" json:"GlyphURI,omitempty"`
	ScaleMode NodeScaleMode `protobuf:"varint,21,opt,name=ScaleMode,proto3,enum=repo.NodeScaleMode" json:"ScaleMode,omitempty"`
	// Text is a human readable descriptor for this item, with TextFormat describing what format it's in.
	Text       string     `protobuf:"bytes,22,opt,name=Text,proto3" json:"Text,omitempty"`
	TextFormat TextFormat `protobuf:"varint,23,opt,name=TextFormat,proto3,enum=repo.TextFormat" json:"TextFormat,omitempty"`
	// Optional values that can express needed values in accordance of TypeID.
	Str string `protobuf:"bytes,24,opt,name=Str,proto3" json:"Str,omitempty"`
	Int int64  `protobuf:"varint,25,opt,name=Int,proto3" json:"Int,omitempty"`
	// Attachment is useful to attach any buffer, typically decoded based on Node.Op, Node.Keypath, or Node.TypeID.
	// Max size is limited to ~ 3.5MB.
	Attachment []byte `protobuf:"bytes,30,opt,name=Attachment,proto3" json:"Attachment,omitempty"`
	// AssetURI specifies an asset URI (typically implicitly placed at this node's position, scale, and orientation.
	// Asset URIs allow the encoding of arbitrary parameters (such as color), allowing variants to be offered at no cost.
	AssetURI string `protobuf:"bytes,35,opt,name=AssetURI,proto3" json:"AssetURI,omitempty"`
	// X1, X2, and X3 are coordinates or values expressed in any unit.
	// A channel client can later declare how to interpret these coordinates so that a channel server and provide indexed services.
	// 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,41,opt,name=X1,proto3" json:"X1,omitempty"`
	X2 float64 `protobuf:"fixed64,42,opt,name=X2,proto3" json:"X2,omitempty"`
	X3 float64 `protobuf:"fixed64,43,opt,name=X3,proto3" json:"X3,omitempty"`
	// Scale1 to Scale3 express the scale of this Node.
	// If all three values are 0, they are all implicitly 1.
	// If Scale2 or Scale3 == 0, then it is implicitly Scale1.
	Scale1 float32 `protobuf:"fixed32,51,opt,name=Scale1,proto3" json:"Scale1,omitempty"`
	Scale2 float32 `protobuf:"fixed32,52,opt,name=Scale2,proto3" json:"Scale2,omitempty"`
	Scale3 float32 `protobuf:"fixed32,53,opt,name=Scale3,proto3" json:"Scale3,omitempty"`
	// Rotate1 - Rotate3 the orientation of this Node using Euler angles.
	Rotate1              float32  `protobuf:"fixed32,60,opt,name=Rotate1,proto3" json:"Rotate1,omitempty"`
	Rotate2              float32  `protobuf:"fixed32,61,opt,name=Rotate2,proto3" json:"Rotate2,omitempty"`
	Rotate3              float32  `protobuf:"fixed32,62,opt,name=Rotate3,proto3" json:"Rotate3,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type NodeOp int32

type NodeScaleMode int32

type RawTx struct {
	// TID identifies this Txn (and is a hash or signature for contained Tx)
	TID []byte `protobuf:"bytes,1,opt,name=TID,proto3" json:"TID,omitempty"`
	// TxnStatus information about the associated txn
	TxnStatus            TxnStatus `protobuf:"varint,2,opt,name=TxnStatus,proto3,enum=repo.TxnStatus" json:"TxnStatus,omitempty"`
	Header               []byte    `protobuf:"bytes,10,opt,name=Header,proto3" json:"Header,omitempty"`
	Body                 []byte    `protobuf:"bytes,11,opt,name=Body,proto3" json:"Body,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

type RepoGrpcClient interface {
	// RepoServiceSession opens the specified channel at a given state and executes a stream of requests from the client.
	// The return stream reports completion or status of active requests and remains open as long as the client stream remains open.
	// The beating heart of PLAN: channels, streams, information, security, trust, sessions.
	RepoServiceSession(ctx context.Context, opts ...grpc.CallOption) (RepoGrpc_RepoServiceSessionClient, error)
}

type RepoGrpcServer interface {
	// RepoServiceSession opens the specified channel at a given state and executes a stream of requests from the client.
	// The return stream reports completion or status of active requests and remains open as long as the client stream remains open.
	// The beating heart of PLAN: channels, streams, information, security, trust, sessions.
	RepoServiceSession(RepoGrpc_RepoServiceSessionServer) error
}

type RepoGrpc_RepoServiceSessionClient interface {
	Send(*ChReq) error
	Recv() (*Node, error)
	grpc.ClientStream
}

type RepoGrpc_RepoServiceSessionServer interface {
	Send(*Node) error
	Recv() (*ChReq, error)
	grpc.ServerStream
}

type ReqErr struct {
	Code ErrCode `protobuf:"varint,1,opt,name=Code,proto3,enum=repo.ErrCode" json:"Code,omitempty"`
	// Msg is a human-readable info string that offers amplifying info about the given error.
	Msg                  string   `protobuf:"bytes,2,opt,name=Msg,proto3" json:"Msg,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type ResolveMode int32

type TID []byte

type TIDBuf [Const_TIDSz]byte

type TextFormat int32

type Tx struct {
	// Derivative content (set to nil for serialization)
	TID  []byte `protobuf:"bytes,1,opt,name=TID,proto3" json:"TID,omitempty"`
	Hash []byte `protobuf:"bytes,2,opt,name=Hash,proto3" json:"Hash,omitempty"`
	// Content
	TxOp                 *TxOp    `protobuf:"bytes,10,opt,name=TxOp,proto3" json:"TxOp,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type TxOp struct {
	// ChStateURI expresses the channel URI that this op applies to.
	ChStateURI *ChStateURI `protobuf:"bytes,3,opt,name=ChStateURI,proto3" json:"ChStateURI,omitempty"`
	// ChannelGenesis creates a new channel in the domain name specified in ChReq.URI.
	// ChReq.Entries[] are entries that are written into the new channel (and are part of the genesis tx).
	// In the corresponding reply ReqComplete message, Node.Str is set to the URI of the newly created channel.
	ChannelGenesis bool `protobuf:"varint,4,opt,name=ChannelGenesis,proto3" json:"ChannelGenesis,omitempty"`
	// Entries are changes to be applied to the target channel.
	Entries              []*Node  `protobuf:"bytes,6,rep,name=Entries,proto3" json:"Entries,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type TxnStatus int32

type UnimplementedRepoGrpcServer struct {
}