list

type AccountAdd struct {
	Identity    crypto.PubKey
	Permissions AclPermissions
	Metadata    []byte
}

type AccountRemovePayload struct {
	Identities []crypto.PubKey
	Change     ReadKeyChangePayload
}

type AccountState struct {
	PubKey            crypto.PubKey
	Permissions       AclPermissions
	Status            AclStatus
	RequestMetadata   []byte
	KeyRecordId       string
	PermissionChanges []PermissionChange
}

type AccountsAddPayload struct {
	Additions []AccountAdd
}

type AclAccountState struct {
	PubKey          crypto.PubKey
	Permissions     AclPermissions
	RequestMetadata []byte
	KeyRecordId     string
}

type AclKeys struct {
	ReadKey         crypto.SymKey
	MetadataPrivKey crypto.PrivKey
	MetadataPubKey  crypto.PubKey
	// contains filtered or unexported fields
}

type AclList interface {
	RWLocker
	Id() string
	Root() *consensusproto.RawRecordWithId
	Records() []*AclRecord
	AclState() *AclState
	IsAfter(first string, second string) (bool, error)
	HasHead(head string) bool
	Head() *AclRecord

	RecordsAfter(ctx context.Context, id string) (records []*consensusproto.RawRecordWithId, err error)
	RecordsBefore(ctx context.Context, headId string) (records []*consensusproto.RawRecordWithId, err error)
	Get(id string) (*AclRecord, error)
	GetIndex(idx int) (*AclRecord, error)
	Iterate(iterFunc IterFunc)
	IterateFrom(startId string, iterFunc IterFunc)

	KeyStorage() crypto.KeyStorage
	RecordBuilder() AclRecordBuilder

	ValidateRawRecord(rawRec *consensusproto.RawRecord, afterValid func(state *AclState) error) (err error)
	AddRawRecord(rawRec *consensusproto.RawRecordWithId) (err error)
	AddRawRecords(rawRecords []*consensusproto.RawRecordWithId) (err error)

	Close(ctx context.Context) (err error)
}

type AclPermissions aclrecordproto.AclUserPermissions

type AclRecord struct {
	Id                string
	PrevId            string
	Timestamp         int64
	AcceptorTimestamp int64
	Data              []byte
	Identity          crypto.PubKey
	AcceptorIdentity  crypto.PubKey
	AcceptorSignature []byte
	Model             interface{}
	Signature         []byte
}

type AclRecordBuilder interface {
	UnmarshallWithId(rawIdRecord *consensusproto.RawRecordWithId) (rec *AclRecord, err error)
	Unmarshall(rawRecord *consensusproto.RawRecord) (rec *AclRecord, err error)

	BuildRoot(content RootContent) (rec *consensusproto.RawRecordWithId, err error)
	BuildBatchRequest(payload BatchRequestPayload) (batchResult BatchResult, err error)
	BuildInvite() (res InviteResult, err error)
	BuildInviteAnyone(permissions AclPermissions) (res InviteResult, err error)
	BuildInviteChange(inviteChange InviteChangePayload) (rawRecord *consensusproto.RawRecord, err error)
	BuildInviteRevoke(inviteRecordId string) (rawRecord *consensusproto.RawRecord, err error)
	BuildInviteJoin(payload InviteJoinPayload) (rawRecord *consensusproto.RawRecord, err error)
	BuildRequestJoin(payload RequestJoinPayload) (rawRecord *consensusproto.RawRecord, err error)
	BuildRequestAccept(payload RequestAcceptPayload) (rawRecord *consensusproto.RawRecord, err error)
	BuildRequestDecline(requestRecordId string) (rawRecord *consensusproto.RawRecord, err error)
	BuildRequestCancel(requestRecordId string) (rawRecord *consensusproto.RawRecord, err error)
	BuildRequestRemove() (rawRecord *consensusproto.RawRecord, err error)
	BuildPermissionChange(payload PermissionChangePayload) (rawRecord *consensusproto.RawRecord, err error)
	BuildPermissionChanges(payload PermissionChangesPayload) (rawRecord *consensusproto.RawRecord, err error)
	BuildReadKeyChange(payload ReadKeyChangePayload) (rawRecord *consensusproto.RawRecord, err error)
	BuildAccountRemove(payload AccountRemovePayload) (rawRecord *consensusproto.RawRecord, err error)
	BuildAccountsAdd(payload AccountsAddPayload) (rawRecord *consensusproto.RawRecord, err error)
}

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

type AclStatus int

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

type BatchRequestPayload struct {
	Additions     []AccountAdd
	Changes       []PermissionChangePayload
	Removals      AccountRemovePayload
	Approvals     []RequestAcceptPayload
	Declines      []string
	InviteRevokes []string
	InviteChanges []InviteChangePayload
	NewInvites    []AclPermissions
}

type BatchResult struct {
	Rec     *consensusproto.RawRecord
	Invites []crypto.PrivKey
}

type ContentValidator interface {
	ValidateAclRecordContents(ch *AclRecord) (err error)
	ValidatePermissionChange(ch *aclrecordproto.AclAccountPermissionChange, authorIdentity crypto.PubKey) (err error)
	ValidatePermissionChanges(ch *aclrecordproto.AclAccountPermissionChanges, authorIdentity crypto.PubKey) (err error)
	ValidateAccountsAdd(ch *aclrecordproto.AclAccountsAdd, authorIdentity crypto.PubKey) (err error)
	ValidateInvite(ch *aclrecordproto.AclAccountInvite, authorIdentity crypto.PubKey) (err error)
	ValidateInviteJoin(ch *aclrecordproto.AclAccountInviteJoin, authorIdentity crypto.PubKey) (err error)
	ValidateInviteChange(ch *aclrecordproto.AclAccountInviteChange, authorIdentity crypto.PubKey) (err error)
	ValidateInviteRevoke(ch *aclrecordproto.AclAccountInviteRevoke, authorIdentity crypto.PubKey) (err error)
	ValidateRequestJoin(ch *aclrecordproto.AclAccountRequestJoin, authorIdentity crypto.PubKey) (err error)
	ValidateRequestAccept(ch *aclrecordproto.AclAccountRequestAccept, authorIdentity crypto.PubKey) (err error)
	ValidateRequestDecline(ch *aclrecordproto.AclAccountRequestDecline, authorIdentity crypto.PubKey) (err error)
	ValidateRequestCancel(ch *aclrecordproto.AclAccountRequestCancel, authorIdentity crypto.PubKey) (err error)
	ValidateAccountRemove(ch *aclrecordproto.AclAccountRemove, authorIdentity crypto.PubKey) (err error)
	ValidateRequestRemove(ch *aclrecordproto.AclAccountRequestRemove, authorIdentity crypto.PubKey) (err error)
	ValidateReadKeyChange(ch *aclrecordproto.AclReadKeyChange, authorIdentity crypto.PubKey) (err error)
}

type Invite struct {
	Key         crypto.PubKey
	Type        aclrecordproto.AclInviteType
	Permissions AclPermissions
	Id          string
	// contains filtered or unexported fields
}

type InviteChangePayload struct {
	IniviteRecordId string
	Permissions     AclPermissions
}

type InviteJoinPayload struct {
	InviteKey crypto.PrivKey
	Metadata  []byte
}

type InviteResult struct {
	InviteRec *consensusproto.RawRecord
	InviteKey crypto.PrivKey
}

type IterFunc = func(record *AclRecord) (IsContinue bool)

type NewInvites struct {
	Permissions AclPermissions
}

type PermissionChange struct {
	RecordId   string
	Permission AclPermissions
}

type PermissionChangePayload struct {
	Identity    crypto.PubKey
	Permissions AclPermissions
}

type PermissionChangesPayload struct {
	Changes []PermissionChangePayload
}

type RWLocker interface {
	sync.Locker
	RLock()
	RUnlock()
}

type ReadKeyChangePayload struct {
	MetadataKey crypto.PrivKey
	ReadKey     crypto.SymKey
}

type RequestAcceptPayload struct {
	RequestRecordId string
	Permissions     AclPermissions
}

type RequestJoinPayload struct {
	InviteKey crypto.PrivKey
	Metadata  []byte
}

type RequestRecord struct {
	RequestIdentity crypto.PubKey
	RequestMetadata []byte
	KeyRecordId     string
	RecordId        string
	Type            RequestType
}

type RequestType int

type RootContent struct {
	PrivKey   crypto.PrivKey
	MasterKey crypto.PrivKey
	SpaceId   string
	Change    ReadKeyChangePayload
	Metadata  []byte
}

type Storage interface {
	Id() string
	Root(ctx context.Context) (StorageRecord, error)
	Head(ctx context.Context) (string, error)
	Has(ctx context.Context, id string) (bool, error)
	Get(ctx context.Context, id string) (StorageRecord, error)
	GetAfterOrder(ctx context.Context, order int, iter StorageIterator) error
	GetBeforeOrder(ctx context.Context, order int, iter StorageIterator) error
	AddAll(ctx context.Context, records []StorageRecord) error
}

type StorageIterator = func(ctx context.Context, record StorageRecord) (shouldContinue bool, err error)

type StorageProvider func(root *consensusproto.RawRecordWithId) (Storage, error)

type StorageRecord struct {
	RawRecord  []byte
	PrevId     string
	Id         string
	Order      int
	ChangeSize int
}

type TestAclState struct {
	Keys *accountdata.AccountKeys
	Acl  AclList
}

type UserPermissionPair struct {
	Identity   crypto.PubKey
	Permission aclrecordproto.AclUserPermissions
}