// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.6
// 	protoc        v3.21.12
// source: aclrecord.proto

package aclrecordproto

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

type AclInviteType int32

const (
	AclInviteType_RequestToJoin AclInviteType = 0
	AclInviteType_AnyoneCanJoin AclInviteType = 1
)

// Enum value maps for AclInviteType.
var (
	AclInviteType_name = map[int32]string{
		0: "RequestToJoin",
		1: "AnyoneCanJoin",
	}
	AclInviteType_value = map[string]int32{
		"RequestToJoin": 0,
		"AnyoneCanJoin": 1,
	}
)

func (x AclInviteType) Enum() *AclInviteType {
	p := new(AclInviteType)
	*p = x
	return p
}

func (x AclInviteType) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (AclInviteType) Descriptor() protoreflect.EnumDescriptor {
	return file_aclrecord_proto_enumTypes[0].Descriptor()
}

func (AclInviteType) Type() protoreflect.EnumType {
	return &file_aclrecord_proto_enumTypes[0]
}

func (x AclInviteType) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use AclInviteType.Descriptor instead.
func (AclInviteType) EnumDescriptor() ([]byte, []int) {
	return file_aclrecord_proto_rawDescGZIP(), []int{0}
}

// AclUserPermissions contains different possible user roles
type AclUserPermissions int32

const (
	AclUserPermissions_None   AclUserPermissions = 0
	AclUserPermissions_Owner  AclUserPermissions = 1
	AclUserPermissions_Admin  AclUserPermissions = 2
	AclUserPermissions_Writer AclUserPermissions = 3
	AclUserPermissions_Reader AclUserPermissions = 4
	AclUserPermissions_Guest  AclUserPermissions = 5
)

// Enum value maps for AclUserPermissions.
var (
	AclUserPermissions_name = map[int32]string{
		0: "None",
		1: "Owner",
		2: "Admin",
		3: "Writer",
		4: "Reader",
		5: "Guest",
	}
	AclUserPermissions_value = map[string]int32{
		"None":   0,
		"Owner":  1,
		"Admin":  2,
		"Writer": 3,
		"Reader": 4,
		"Guest":  5,
	}
)

func (x AclUserPermissions) Enum() *AclUserPermissions {
	p := new(AclUserPermissions)
	*p = x
	return p
}

func (x AclUserPermissions) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (AclUserPermissions) Descriptor() protoreflect.EnumDescriptor {
	return file_aclrecord_proto_enumTypes[1].Descriptor()
}

func (AclUserPermissions) Type() protoreflect.EnumType {
	return &file_aclrecord_proto_enumTypes[1]
}

func (x AclUserPermissions) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use AclUserPermissions.Descriptor instead.
func (AclUserPermissions) EnumDescriptor() ([]byte, []int) {
	return file_aclrecord_proto_rawDescGZIP(), []int{1}
}

// AclRoot is a root of access control list
type AclRoot struct {
	state                    protoimpl.MessageState `protogen:"open.v1"`
	Identity                 []byte                 `protobuf:"bytes,1,opt,name=identity,proto3" json:"identity,omitempty"`
	MasterKey                []byte                 `protobuf:"bytes,2,opt,name=masterKey,proto3" json:"masterKey,omitempty"`
	SpaceId                  string                 `protobuf:"bytes,3,opt,name=spaceId,proto3" json:"spaceId,omitempty"`
	EncryptedReadKey         []byte                 `protobuf:"bytes,4,opt,name=encryptedReadKey,proto3" json:"encryptedReadKey,omitempty"`
	Timestamp                int64                  `protobuf:"varint,5,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	IdentitySignature        []byte                 `protobuf:"bytes,6,opt,name=identitySignature,proto3" json:"identitySignature,omitempty"`
	MetadataPubKey           []byte                 `protobuf:"bytes,7,opt,name=metadataPubKey,proto3" json:"metadataPubKey,omitempty"`
	EncryptedMetadataPrivKey []byte                 `protobuf:"bytes,8,opt,name=encryptedMetadataPrivKey,proto3" json:"encryptedMetadataPrivKey,omitempty"`
	EncryptedOwnerMetadata   []byte                 `protobuf:"bytes,9,opt,name=encryptedOwnerMetadata,proto3" json:"encryptedOwnerMetadata,omitempty"`
	OneToOneInfo             *AclOneToOneInfo       `protobuf:"bytes,10,opt,name=oneToOneInfo,proto3" json:"oneToOneInfo,omitempty"`
	unknownFields            protoimpl.UnknownFields
	sizeCache                protoimpl.SizeCache
}

func (x *AclRoot) Reset() {
	*x = AclRoot{}
	mi := &file_aclrecord_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AclRoot) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AclRoot) ProtoMessage() {}

func (x *AclRoot) ProtoReflect() protoreflect.Message {
	mi := &file_aclrecord_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AclRoot.ProtoReflect.Descriptor instead.
func (*AclRoot) Descriptor() ([]byte, []int) {
	return file_aclrecord_proto_rawDescGZIP(), []int{0}
}

func (x *AclRoot) GetIdentity() []byte {
	if x != nil {
		return x.Identity
	}
	return nil
}

func (x *AclRoot) GetMasterKey() []byte {
	if x != nil {
		return x.MasterKey
	}
	return nil
}

func (x *AclRoot) GetSpaceId() string {
	if x != nil {
		return x.SpaceId
	}
	return ""
}

func (x *AclRoot) GetEncryptedReadKey() []byte {
	if x != nil {
		return x.EncryptedReadKey
	}
	return nil
}

func (x *AclRoot) GetTimestamp() int64 {
	if x != nil {
		return x.Timestamp
	}
	return 0
}

func (x *AclRoot) GetIdentitySignature() []byte {
	if x != nil {
		return x.IdentitySignature
	}
	return nil
}

func (x *AclRoot) GetMetadataPubKey() []byte {
	if x != nil {
		return x.MetadataPubKey
	}
	return nil
}

func (x *AclRoot) GetEncryptedMetadataPrivKey() []byte {
	if x != nil {
		return x.EncryptedMetadataPrivKey
	}
	return nil
}

func (x *AclRoot) GetEncryptedOwnerMetadata() []byte {
	if x != nil {
		return x.EncryptedOwnerMetadata
	}
	return nil
}

func (x *AclRoot) GetOneToOneInfo() *AclOneToOneInfo {
	if x != nil {
		return x.OneToOneInfo
	}
	return nil
}

// AclOneToOneInfo exists if its one-to-one space acl record
type AclOneToOneInfo struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Owner         []byte                 `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"`
	Writers       [][]byte               `protobuf:"bytes,2,rep,name=writers,proto3" json:"writers,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AclOneToOneInfo) Reset() {
	*x = AclOneToOneInfo{}
	mi := &file_aclrecord_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AclOneToOneInfo) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AclOneToOneInfo) ProtoMessage() {}

func (x *AclOneToOneInfo) ProtoReflect() protoreflect.Message {
	mi := &file_aclrecord_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AclOneToOneInfo.ProtoReflect.Descriptor instead.
func (*AclOneToOneInfo) Descriptor() ([]byte, []int) {
	return file_aclrecord_proto_rawDescGZIP(), []int{1}
}

func (x *AclOneToOneInfo) GetOwner() []byte {
	if x != nil {
		return x.Owner
	}
	return nil
}

func (x *AclOneToOneInfo) GetWriters() [][]byte {
	if x != nil {
		return x.Writers
	}
	return nil
}

// AclAccountInvite contains the public invite key, the private part of which is sent to the user directly
type AclAccountInvite struct {
	state            protoimpl.MessageState `protogen:"open.v1"`
	InviteKey        []byte                 `protobuf:"bytes,1,opt,name=inviteKey,proto3" json:"inviteKey,omitempty"`
	InviteType       AclInviteType          `protobuf:"varint,2,opt,name=inviteType,proto3,enum=aclrecord.AclInviteType" json:"inviteType,omitempty"`
	Permissions      AclUserPermissions     `protobuf:"varint,3,opt,name=permissions,proto3,enum=aclrecord.AclUserPermissions" json:"permissions,omitempty"`
	EncryptedReadKey []byte                 `protobuf:"bytes,4,opt,name=encryptedReadKey,proto3" json:"encryptedReadKey,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

func (x *AclAccountInvite) Reset() {
	*x = AclAccountInvite{}
	mi := &file_aclrecord_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AclAccountInvite) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AclAccountInvite) ProtoMessage() {}

func (x *AclAccountInvite) ProtoReflect() protoreflect.Message {
	mi := &file_aclrecord_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AclAccountInvite.ProtoReflect.Descriptor instead.
func (*AclAccountInvite) Descriptor() ([]byte, []int) {
	return file_aclrecord_proto_rawDescGZIP(), []int{2}
}

func (x *AclAccountInvite) GetInviteKey() []byte {
	if x != nil {
		return x.InviteKey
	}
	return nil
}

func (x *AclAccountInvite) GetInviteType() AclInviteType {
	if x != nil {
		return x.InviteType
	}
	return AclInviteType_RequestToJoin
}

func (x *AclAccountInvite) GetPermissions() AclUserPermissions {
	if x != nil {
		return x.Permissions
	}
	return AclUserPermissions_None
}

func (x *AclAccountInvite) GetEncryptedReadKey() []byte {
	if x != nil {
		return x.EncryptedReadKey
	}
	return nil
}

type AclAccountInviteChange struct {
	state          protoimpl.MessageState `protogen:"open.v1"`
	InviteRecordId string                 `protobuf:"bytes,1,opt,name=inviteRecordId,proto3" json:"inviteRecordId,omitempty"`
	Permissions    AclUserPermissions     `protobuf:"varint,2,opt,name=permissions,proto3,enum=aclrecord.AclUserPermissions" json:"permissions,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *AclAccountInviteChange) Reset() {
	*x = AclAccountInviteChange{}
	mi := &file_aclrecord_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AclAccountInviteChange) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AclAccountInviteChange) ProtoMessage() {}

func (x *AclAccountInviteChange) ProtoReflect() protoreflect.Message {
	mi := &file_aclrecord_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AclAccountInviteChange.ProtoReflect.Descriptor instead.
func (*AclAccountInviteChange) Descriptor() ([]byte, []int) {
	return file_aclrecord_proto_rawDescGZIP(), []int{3}
}

func (x *AclAccountInviteChange) GetInviteRecordId() string {
	if x != nil {
		return x.InviteRecordId
	}
	return ""
}

func (x *AclAccountInviteChange) GetPermissions() AclUserPermissions {
	if x != nil {
		return x.Permissions
	}
	return AclUserPermissions_None
}

// AclOwnershipChange contains the new owner identity
type AclOwnershipChange struct {
	state               protoimpl.MessageState `protogen:"open.v1"`
	NewOwnerIdentity    []byte                 `protobuf:"bytes,1,opt,name=newOwnerIdentity,proto3" json:"newOwnerIdentity,omitempty"`
	OldOwnerPermissions AclUserPermissions     `protobuf:"varint,2,opt,name=oldOwnerPermissions,proto3,enum=aclrecord.AclUserPermissions" json:"oldOwnerPermissions,omitempty"`
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

func (x *AclOwnershipChange) Reset() {
	*x = AclOwnershipChange{}
	mi := &file_aclrecord_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AclOwnershipChange) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AclOwnershipChange) ProtoMessage() {}

func (x *AclOwnershipChange) ProtoReflect() protoreflect.Message {
	mi := &file_aclrecord_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AclOwnershipChange.ProtoReflect.Descriptor instead.
func (*AclOwnershipChange) Descriptor() ([]byte, []int) {
	return file_aclrecord_proto_rawDescGZIP(), []int{4}
}

func (x *AclOwnershipChange) GetNewOwnerIdentity() []byte {
	if x != nil {
		return x.NewOwnerIdentity
	}
	return nil
}

func (x *AclOwnershipChange) GetOldOwnerPermissions() AclUserPermissions {
	if x != nil {
		return x.OldOwnerPermissions
	}
	return AclUserPermissions_None
}

// AclAccountRequestJoin contains the reference to the invite record and the data of the person who wants to join, confirmed by the private invite key
type AclAccountRequestJoin struct {
	state                   protoimpl.MessageState `protogen:"open.v1"`
	InviteIdentity          []byte                 `protobuf:"bytes,1,opt,name=inviteIdentity,proto3" json:"inviteIdentity,omitempty"`
	InviteRecordId          string                 `protobuf:"bytes,2,opt,name=inviteRecordId,proto3" json:"inviteRecordId,omitempty"`
	InviteIdentitySignature []byte                 `protobuf:"bytes,3,opt,name=inviteIdentitySignature,proto3" json:"inviteIdentitySignature,omitempty"`
	// Metadata is encrypted with metadata key of the space
	Metadata      []byte `protobuf:"bytes,4,opt,name=metadata,proto3" json:"metadata,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AclAccountRequestJoin) Reset() {
	*x = AclAccountRequestJoin{}
	mi := &file_aclrecord_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AclAccountRequestJoin) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AclAccountRequestJoin) ProtoMessage() {}

func (x *AclAccountRequestJoin) ProtoReflect() protoreflect.Message {
	mi := &file_aclrecord_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AclAccountRequestJoin.ProtoReflect.Descriptor instead.
func (*AclAccountRequestJoin) Descriptor() ([]byte, []int) {
	return file_aclrecord_proto_rawDescGZIP(), []int{5}
}

func (x *AclAccountRequestJoin) GetInviteIdentity() []byte {
	if x != nil {
		return x.InviteIdentity
	}
	return nil
}

func (x *AclAccountRequestJoin) GetInviteRecordId() string {
	if x != nil {
		return x.InviteRecordId
	}
	return ""
}

func (x *AclAccountRequestJoin) GetInviteIdentitySignature() []byte {
	if x != nil {
		return x.InviteIdentitySignature
	}
	return nil
}

func (x *AclAccountRequestJoin) GetMetadata() []byte {
	if x != nil {
		return x.Metadata
	}
	return nil
}

// AclInviteJoin contains the reference to the invite record and the data of the person who wants to join, confirmed by the private invite key
// The person must encrypt the key with its own public key
type AclAccountInviteJoin struct {
	state                   protoimpl.MessageState `protogen:"open.v1"`
	Identity                []byte                 `protobuf:"bytes,1,opt,name=identity,proto3" json:"identity,omitempty"`
	InviteRecordId          string                 `protobuf:"bytes,2,opt,name=inviteRecordId,proto3" json:"inviteRecordId,omitempty"`
	InviteIdentitySignature []byte                 `protobuf:"bytes,3,opt,name=inviteIdentitySignature,proto3" json:"inviteIdentitySignature,omitempty"`
	// Metadata is encrypted with metadata key of the space
	Metadata         []byte             `protobuf:"bytes,4,opt,name=metadata,proto3" json:"metadata,omitempty"`
	EncryptedReadKey []byte             `protobuf:"bytes,5,opt,name=encryptedReadKey,proto3" json:"encryptedReadKey,omitempty"`
	Permissions      AclUserPermissions `protobuf:"varint,6,opt,name=permissions,proto3,enum=aclrecord.AclUserPermissions" json:"permissions,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

func (x *AclAccountInviteJoin) Reset() {
	*x = AclAccountInviteJoin{}
	mi := &file_aclrecord_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AclAccountInviteJoin) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AclAccountInviteJoin) ProtoMessage() {}

func (x *AclAccountInviteJoin) ProtoReflect() protoreflect.Message {
	mi := &file_aclrecord_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AclAccountInviteJoin.ProtoReflect.Descriptor instead.
func (*AclAccountInviteJoin) Descriptor() ([]byte, []int) {
	return file_aclrecord_proto_rawDescGZIP(), []int{6}
}

func (x *AclAccountInviteJoin) GetIdentity() []byte {
	if x != nil {
		return x.Identity
	}
	return nil
}

func (x *AclAccountInviteJoin) GetInviteRecordId() string {
	if x != nil {
		return x.InviteRecordId
	}
	return ""
}

func (x *AclAccountInviteJoin) GetInviteIdentitySignature() []byte {
	if x != nil {
		return x.InviteIdentitySignature
	}
	return nil
}

func (x *AclAccountInviteJoin) GetMetadata() []byte {
	if x != nil {
		return x.Metadata
	}
	return nil
}

func (x *AclAccountInviteJoin) GetEncryptedReadKey() []byte {
	if x != nil {
		return x.EncryptedReadKey
	}
	return nil
}

func (x *AclAccountInviteJoin) GetPermissions() AclUserPermissions {
	if x != nil {
		return x.Permissions
	}
	return AclUserPermissions_None
}

// AclAccountRequestAccept contains the reference to join record and all read keys, encrypted with the identity of the requestor
type AclAccountRequestAccept struct {
	state            protoimpl.MessageState `protogen:"open.v1"`
	Identity         []byte                 `protobuf:"bytes,1,opt,name=identity,proto3" json:"identity,omitempty"`
	RequestRecordId  string                 `protobuf:"bytes,2,opt,name=requestRecordId,proto3" json:"requestRecordId,omitempty"`
	EncryptedReadKey []byte                 `protobuf:"bytes,3,opt,name=encryptedReadKey,proto3" json:"encryptedReadKey,omitempty"`
	Permissions      AclUserPermissions     `protobuf:"varint,4,opt,name=permissions,proto3,enum=aclrecord.AclUserPermissions" json:"permissions,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

func (x *AclAccountRequestAccept) Reset() {
	*x = AclAccountRequestAccept{}
	mi := &file_aclrecord_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AclAccountRequestAccept) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AclAccountRequestAccept) ProtoMessage() {}

func (x *AclAccountRequestAccept) ProtoReflect() protoreflect.Message {
	mi := &file_aclrecord_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AclAccountRequestAccept.ProtoReflect.Descriptor instead.
func (*AclAccountRequestAccept) Descriptor() ([]byte, []int) {
	return file_aclrecord_proto_rawDescGZIP(), []int{7}
}

func (x *AclAccountRequestAccept) GetIdentity() []byte {
	if x != nil {
		return x.Identity
	}
	return nil
}

func (x *AclAccountRequestAccept) GetRequestRecordId() string {
	if x != nil {
		return x.RequestRecordId
	}
	return ""
}

func (x *AclAccountRequestAccept) GetEncryptedReadKey() []byte {
	if x != nil {
		return x.EncryptedReadKey
	}
	return nil
}

func (x *AclAccountRequestAccept) GetPermissions() AclUserPermissions {
	if x != nil {
		return x.Permissions
	}
	return AclUserPermissions_None
}

// AclAccountRequestDecline contains the reference to join record
type AclAccountRequestDecline struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	RequestRecordId string                 `protobuf:"bytes,1,opt,name=requestRecordId,proto3" json:"requestRecordId,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *AclAccountRequestDecline) Reset() {
	*x = AclAccountRequestDecline{}
	mi := &file_aclrecord_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AclAccountRequestDecline) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AclAccountRequestDecline) ProtoMessage() {}

func (x *AclAccountRequestDecline) ProtoReflect() protoreflect.Message {
	mi := &file_aclrecord_proto_msgTypes[8]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AclAccountRequestDecline.ProtoReflect.Descriptor instead.
func (*AclAccountRequestDecline) Descriptor() ([]byte, []int) {
	return file_aclrecord_proto_rawDescGZIP(), []int{8}
}

func (x *AclAccountRequestDecline) GetRequestRecordId() string {
	if x != nil {
		return x.RequestRecordId
	}
	return ""
}

// AclAccountInviteRevoke revokes the invite record
type AclAccountInviteRevoke struct {
	state          protoimpl.MessageState `protogen:"open.v1"`
	InviteRecordId string                 `protobuf:"bytes,1,opt,name=inviteRecordId,proto3" json:"inviteRecordId,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *AclAccountInviteRevoke) Reset() {
	*x = AclAccountInviteRevoke{}
	mi := &file_aclrecord_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AclAccountInviteRevoke) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AclAccountInviteRevoke) ProtoMessage() {}

func (x *AclAccountInviteRevoke) ProtoReflect() protoreflect.Message {
	mi := &file_aclrecord_proto_msgTypes[9]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AclAccountInviteRevoke.ProtoReflect.Descriptor instead.
func (*AclAccountInviteRevoke) Descriptor() ([]byte, []int) {
	return file_aclrecord_proto_rawDescGZIP(), []int{9}
}

func (x *AclAccountInviteRevoke) GetInviteRecordId() string {
	if x != nil {
		return x.InviteRecordId
	}
	return ""
}

// AclEncryptedReadKeys are new key for specific identity
type AclEncryptedReadKey struct {
	state            protoimpl.MessageState `protogen:"open.v1"`
	Identity         []byte                 `protobuf:"bytes,1,opt,name=identity,proto3" json:"identity,omitempty"`
	EncryptedReadKey []byte                 `protobuf:"bytes,2,opt,name=encryptedReadKey,proto3" json:"encryptedReadKey,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

func (x *AclEncryptedReadKey) Reset() {
	*x = AclEncryptedReadKey{}
	mi := &file_aclrecord_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AclEncryptedReadKey) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AclEncryptedReadKey) ProtoMessage() {}

func (x *AclEncryptedReadKey) ProtoReflect() protoreflect.Message {
	mi := &file_aclrecord_proto_msgTypes[10]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AclEncryptedReadKey.ProtoReflect.Descriptor instead.
func (*AclEncryptedReadKey) Descriptor() ([]byte, []int) {
	return file_aclrecord_proto_rawDescGZIP(), []int{10}
}

func (x *AclEncryptedReadKey) GetIdentity() []byte {
	if x != nil {
		return x.Identity
	}
	return nil
}

func (x *AclEncryptedReadKey) GetEncryptedReadKey() []byte {
	if x != nil {
		return x.EncryptedReadKey
	}
	return nil
}

// AclAccountPermissionChanges contains permission changes for certain identities
type AclAccountPermissionChanges struct {
	state         protoimpl.MessageState        `protogen:"open.v1"`
	Changes       []*AclAccountPermissionChange `protobuf:"bytes,1,rep,name=changes,proto3" json:"changes,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AclAccountPermissionChanges) Reset() {
	*x = AclAccountPermissionChanges{}
	mi := &file_aclrecord_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AclAccountPermissionChanges) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AclAccountPermissionChanges) ProtoMessage() {}

func (x *AclAccountPermissionChanges) ProtoReflect() protoreflect.Message {
	mi := &file_aclrecord_proto_msgTypes[11]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AclAccountPermissionChanges.ProtoReflect.Descriptor instead.
func (*AclAccountPermissionChanges) Descriptor() ([]byte, []int) {
	return file_aclrecord_proto_rawDescGZIP(), []int{11}
}

func (x *AclAccountPermissionChanges) GetChanges() []*AclAccountPermissionChange {
	if x != nil {
		return x.Changes
	}
	return nil
}

// AclAccountsAdd contains new accounts to be added
type AclAccountsAdd struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Additions     []*AclAccountAdd       `protobuf:"bytes,1,rep,name=additions,proto3" json:"additions,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AclAccountsAdd) Reset() {
	*x = AclAccountsAdd{}
	mi := &file_aclrecord_proto_msgTypes[12]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AclAccountsAdd) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AclAccountsAdd) ProtoMessage() {}

func (x *AclAccountsAdd) ProtoReflect() protoreflect.Message {
	mi := &file_aclrecord_proto_msgTypes[12]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AclAccountsAdd.ProtoReflect.Descriptor instead.
func (*AclAccountsAdd) Descriptor() ([]byte, []int) {
	return file_aclrecord_proto_rawDescGZIP(), []int{12}
}

func (x *AclAccountsAdd) GetAdditions() []*AclAccountAdd {
	if x != nil {
		return x.Additions
	}
	return nil
}

// AclAccountAdd contains new account to be added
type AclAccountAdd struct {
	state            protoimpl.MessageState `protogen:"open.v1"`
	Identity         []byte                 `protobuf:"bytes,1,opt,name=identity,proto3" json:"identity,omitempty"`
	Permissions      AclUserPermissions     `protobuf:"varint,2,opt,name=permissions,proto3,enum=aclrecord.AclUserPermissions" json:"permissions,omitempty"`
	Metadata         []byte                 `protobuf:"bytes,3,opt,name=metadata,proto3" json:"metadata,omitempty"`
	EncryptedReadKey []byte                 `protobuf:"bytes,4,opt,name=encryptedReadKey,proto3" json:"encryptedReadKey,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

func (x *AclAccountAdd) Reset() {
	*x = AclAccountAdd{}
	mi := &file_aclrecord_proto_msgTypes[13]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AclAccountAdd) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AclAccountAdd) ProtoMessage() {}

func (x *AclAccountAdd) ProtoReflect() protoreflect.Message {
	mi := &file_aclrecord_proto_msgTypes[13]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AclAccountAdd.ProtoReflect.Descriptor instead.
func (*AclAccountAdd) Descriptor() ([]byte, []int) {
	return file_aclrecord_proto_rawDescGZIP(), []int{13}
}

func (x *AclAccountAdd) GetIdentity() []byte {
	if x != nil {
		return x.Identity
	}
	return nil
}

func (x *AclAccountAdd) GetPermissions() AclUserPermissions {
	if x != nil {
		return x.Permissions
	}
	return AclUserPermissions_None
}

func (x *AclAccountAdd) GetMetadata() []byte {
	if x != nil {
		return x.Metadata
	}
	return nil
}

func (x *AclAccountAdd) GetEncryptedReadKey() []byte {
	if x != nil {
		return x.EncryptedReadKey
	}
	return nil
}

// AclRequestCancel contains reference to the request that is canceled by the account
type AclAccountRequestCancel struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	RecordId      string                 `protobuf:"bytes,1,opt,name=recordId,proto3" json:"recordId,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AclAccountRequestCancel) Reset() {
	*x = AclAccountRequestCancel{}
	mi := &file_aclrecord_proto_msgTypes[14]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AclAccountRequestCancel) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AclAccountRequestCancel) ProtoMessage() {}

func (x *AclAccountRequestCancel) ProtoReflect() protoreflect.Message {
	mi := &file_aclrecord_proto_msgTypes[14]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AclAccountRequestCancel.ProtoReflect.Descriptor instead.
func (*AclAccountRequestCancel) Descriptor() ([]byte, []int) {
	return file_aclrecord_proto_rawDescGZIP(), []int{14}
}

func (x *AclAccountRequestCancel) GetRecordId() string {
	if x != nil {
		return x.RecordId
	}
	return ""
}

// AclAccountPermissionChange changes permissions of specific account
type AclAccountPermissionChange struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Identity      []byte                 `protobuf:"bytes,1,opt,name=identity,proto3" json:"identity,omitempty"`
	Permissions   AclUserPermissions     `protobuf:"varint,2,opt,name=permissions,proto3,enum=aclrecord.AclUserPermissions" json:"permissions,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AclAccountPermissionChange) Reset() {
	*x = AclAccountPermissionChange{}
	mi := &file_aclrecord_proto_msgTypes[15]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AclAccountPermissionChange) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AclAccountPermissionChange) ProtoMessage() {}

func (x *AclAccountPermissionChange) ProtoReflect() protoreflect.Message {
	mi := &file_aclrecord_proto_msgTypes[15]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AclAccountPermissionChange.ProtoReflect.Descriptor instead.
func (*AclAccountPermissionChange) Descriptor() ([]byte, []int) {
	return file_aclrecord_proto_rawDescGZIP(), []int{15}
}

func (x *AclAccountPermissionChange) GetIdentity() []byte {
	if x != nil {
		return x.Identity
	}
	return nil
}

func (x *AclAccountPermissionChange) GetPermissions() AclUserPermissions {
	if x != nil {
		return x.Permissions
	}
	return AclUserPermissions_None
}

// AclReadKeyChange changes the key for a space
type AclReadKeyChange struct {
	state          protoimpl.MessageState `protogen:"open.v1"`
	AccountKeys    []*AclEncryptedReadKey `protobuf:"bytes,1,rep,name=accountKeys,proto3" json:"accountKeys,omitempty"`
	MetadataPubKey []byte                 `protobuf:"bytes,2,opt,name=metadataPubKey,proto3" json:"metadataPubKey,omitempty"`
	// EncryptedMetadataPrivKey is encrypted with new read key
	EncryptedMetadataPrivKey []byte `protobuf:"bytes,3,opt,name=encryptedMetadataPrivKey,proto3" json:"encryptedMetadataPrivKey,omitempty"`
	// EncryptedOldReadKey is encrypted with new read key
	EncryptedOldReadKey []byte                 `protobuf:"bytes,4,opt,name=encryptedOldReadKey,proto3" json:"encryptedOldReadKey,omitempty"`
	InviteKeys          []*AclEncryptedReadKey `protobuf:"bytes,5,rep,name=inviteKeys,proto3" json:"inviteKeys,omitempty"`
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

func (x *AclReadKeyChange) Reset() {
	*x = AclReadKeyChange{}
	mi := &file_aclrecord_proto_msgTypes[16]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AclReadKeyChange) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AclReadKeyChange) ProtoMessage() {}

func (x *AclReadKeyChange) ProtoReflect() protoreflect.Message {
	mi := &file_aclrecord_proto_msgTypes[16]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AclReadKeyChange.ProtoReflect.Descriptor instead.
func (*AclReadKeyChange) Descriptor() ([]byte, []int) {
	return file_aclrecord_proto_rawDescGZIP(), []int{16}
}

func (x *AclReadKeyChange) GetAccountKeys() []*AclEncryptedReadKey {
	if x != nil {
		return x.AccountKeys
	}
	return nil
}

func (x *AclReadKeyChange) GetMetadataPubKey() []byte {
	if x != nil {
		return x.MetadataPubKey
	}
	return nil
}

func (x *AclReadKeyChange) GetEncryptedMetadataPrivKey() []byte {
	if x != nil {
		return x.EncryptedMetadataPrivKey
	}
	return nil
}

func (x *AclReadKeyChange) GetEncryptedOldReadKey() []byte {
	if x != nil {
		return x.EncryptedOldReadKey
	}
	return nil
}

func (x *AclReadKeyChange) GetInviteKeys() []*AclEncryptedReadKey {
	if x != nil {
		return x.InviteKeys
	}
	return nil
}

// AclAccountRemove removes an account and changes read key for space
type AclAccountRemove struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Identities    [][]byte               `protobuf:"bytes,1,rep,name=identities,proto3" json:"identities,omitempty"`
	ReadKeyChange *AclReadKeyChange      `protobuf:"bytes,2,opt,name=readKeyChange,proto3" json:"readKeyChange,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AclAccountRemove) Reset() {
	*x = AclAccountRemove{}
	mi := &file_aclrecord_proto_msgTypes[17]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AclAccountRemove) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AclAccountRemove) ProtoMessage() {}

func (x *AclAccountRemove) ProtoReflect() protoreflect.Message {
	mi := &file_aclrecord_proto_msgTypes[17]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AclAccountRemove.ProtoReflect.Descriptor instead.
func (*AclAccountRemove) Descriptor() ([]byte, []int) {
	return file_aclrecord_proto_rawDescGZIP(), []int{17}
}

func (x *AclAccountRemove) GetIdentities() [][]byte {
	if x != nil {
		return x.Identities
	}
	return nil
}

func (x *AclAccountRemove) GetReadKeyChange() *AclReadKeyChange {
	if x != nil {
		return x.ReadKeyChange
	}
	return nil
}

// AclAccountRequestRemove adds a request to remove an account
type AclAccountRequestRemove struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AclAccountRequestRemove) Reset() {
	*x = AclAccountRequestRemove{}
	mi := &file_aclrecord_proto_msgTypes[18]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AclAccountRequestRemove) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AclAccountRequestRemove) ProtoMessage() {}

func (x *AclAccountRequestRemove) ProtoReflect() protoreflect.Message {
	mi := &file_aclrecord_proto_msgTypes[18]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AclAccountRequestRemove.ProtoReflect.Descriptor instead.
func (*AclAccountRequestRemove) Descriptor() ([]byte, []int) {
	return file_aclrecord_proto_rawDescGZIP(), []int{18}
}

// AclContentValue contains possible values for Acl
type AclContentValue struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Value:
	//
	//	*AclContentValue_Invite
	//	*AclContentValue_InviteRevoke
	//	*AclContentValue_RequestJoin
	//	*AclContentValue_RequestAccept
	//	*AclContentValue_PermissionChange
	//	*AclContentValue_AccountRemove
	//	*AclContentValue_ReadKeyChange
	//	*AclContentValue_RequestDecline
	//	*AclContentValue_AccountRequestRemove
	//	*AclContentValue_PermissionChanges
	//	*AclContentValue_AccountsAdd
	//	*AclContentValue_RequestCancel
	//	*AclContentValue_InviteJoin
	//	*AclContentValue_InviteChange
	//	*AclContentValue_OwnershipChange
	Value         isAclContentValue_Value `protobuf_oneof:"value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AclContentValue) Reset() {
	*x = AclContentValue{}
	mi := &file_aclrecord_proto_msgTypes[19]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AclContentValue) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AclContentValue) ProtoMessage() {}

func (x *AclContentValue) ProtoReflect() protoreflect.Message {
	mi := &file_aclrecord_proto_msgTypes[19]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AclContentValue.ProtoReflect.Descriptor instead.
func (*AclContentValue) Descriptor() ([]byte, []int) {
	return file_aclrecord_proto_rawDescGZIP(), []int{19}
}

func (x *AclContentValue) GetValue() isAclContentValue_Value {
	if x != nil {
		return x.Value
	}
	return nil
}

func (x *AclContentValue) GetInvite() *AclAccountInvite {
	if x != nil {
		if x, ok := x.Value.(*AclContentValue_Invite); ok {
			return x.Invite
		}
	}
	return nil
}

func (x *AclContentValue) GetInviteRevoke() *AclAccountInviteRevoke {
	if x != nil {
		if x, ok := x.Value.(*AclContentValue_InviteRevoke); ok {
			return x.InviteRevoke
		}
	}
	return nil
}

func (x *AclContentValue) GetRequestJoin() *AclAccountRequestJoin {
	if x != nil {
		if x, ok := x.Value.(*AclContentValue_RequestJoin); ok {
			return x.RequestJoin
		}
	}
	return nil
}

func (x *AclContentValue) GetRequestAccept() *AclAccountRequestAccept {
	if x != nil {
		if x, ok := x.Value.(*AclContentValue_RequestAccept); ok {
			return x.RequestAccept
		}
	}
	return nil
}

func (x *AclContentValue) GetPermissionChange() *AclAccountPermissionChange {
	if x != nil {
		if x, ok := x.Value.(*AclContentValue_PermissionChange); ok {
			return x.PermissionChange
		}
	}
	return nil
}

func (x *AclContentValue) GetAccountRemove() *AclAccountRemove {
	if x != nil {
		if x, ok := x.Value.(*AclContentValue_AccountRemove); ok {
			return x.AccountRemove
		}
	}
	return nil
}

func (x *AclContentValue) GetReadKeyChange() *AclReadKeyChange {
	if x != nil {
		if x, ok := x.Value.(*AclContentValue_ReadKeyChange); ok {
			return x.ReadKeyChange
		}
	}
	return nil
}

func (x *AclContentValue) GetRequestDecline() *AclAccountRequestDecline {
	if x != nil {
		if x, ok := x.Value.(*AclContentValue_RequestDecline); ok {
			return x.RequestDecline
		}
	}
	return nil
}

func (x *AclContentValue) GetAccountRequestRemove() *AclAccountRequestRemove {
	if x != nil {
		if x, ok := x.Value.(*AclContentValue_AccountRequestRemove); ok {
			return x.AccountRequestRemove
		}
	}
	return nil
}

func (x *AclContentValue) GetPermissionChanges() *AclAccountPermissionChanges {
	if x != nil {
		if x, ok := x.Value.(*AclContentValue_PermissionChanges); ok {
			return x.PermissionChanges
		}
	}
	return nil
}

func (x *AclContentValue) GetAccountsAdd() *AclAccountsAdd {
	if x != nil {
		if x, ok := x.Value.(*AclContentValue_AccountsAdd); ok {
			return x.AccountsAdd
		}
	}
	return nil
}

func (x *AclContentValue) GetRequestCancel() *AclAccountRequestCancel {
	if x != nil {
		if x, ok := x.Value.(*AclContentValue_RequestCancel); ok {
			return x.RequestCancel
		}
	}
	return nil
}

func (x *AclContentValue) GetInviteJoin() *AclAccountInviteJoin {
	if x != nil {
		if x, ok := x.Value.(*AclContentValue_InviteJoin); ok {
			return x.InviteJoin
		}
	}
	return nil
}

func (x *AclContentValue) GetInviteChange() *AclAccountInviteChange {
	if x != nil {
		if x, ok := x.Value.(*AclContentValue_InviteChange); ok {
			return x.InviteChange
		}
	}
	return nil
}

func (x *AclContentValue) GetOwnershipChange() *AclOwnershipChange {
	if x != nil {
		if x, ok := x.Value.(*AclContentValue_OwnershipChange); ok {
			return x.OwnershipChange
		}
	}
	return nil
}

type isAclContentValue_Value interface {
	isAclContentValue_Value()
}

type AclContentValue_Invite struct {
	Invite *AclAccountInvite `protobuf:"bytes,1,opt,name=invite,proto3,oneof"`
}

type AclContentValue_InviteRevoke struct {
	InviteRevoke *AclAccountInviteRevoke `protobuf:"bytes,2,opt,name=inviteRevoke,proto3,oneof"`
}

type AclContentValue_RequestJoin struct {
	RequestJoin *AclAccountRequestJoin `protobuf:"bytes,3,opt,name=requestJoin,proto3,oneof"`
}

type AclContentValue_RequestAccept struct {
	RequestAccept *AclAccountRequestAccept `protobuf:"bytes,4,opt,name=requestAccept,proto3,oneof"`
}

type AclContentValue_PermissionChange struct {
	// AclAccountPermissionChange deprecated
	PermissionChange *AclAccountPermissionChange `protobuf:"bytes,5,opt,name=permissionChange,proto3,oneof"`
}

type AclContentValue_AccountRemove struct {
	AccountRemove *AclAccountRemove `protobuf:"bytes,6,opt,name=accountRemove,proto3,oneof"`
}

type AclContentValue_ReadKeyChange struct {
	ReadKeyChange *AclReadKeyChange `protobuf:"bytes,7,opt,name=readKeyChange,proto3,oneof"`
}

type AclContentValue_RequestDecline struct {
	RequestDecline *AclAccountRequestDecline `protobuf:"bytes,8,opt,name=requestDecline,proto3,oneof"`
}

type AclContentValue_AccountRequestRemove struct {
	AccountRequestRemove *AclAccountRequestRemove `protobuf:"bytes,9,opt,name=accountRequestRemove,proto3,oneof"`
}

type AclContentValue_PermissionChanges struct {
	PermissionChanges *AclAccountPermissionChanges `protobuf:"bytes,10,opt,name=permissionChanges,proto3,oneof"`
}

type AclContentValue_AccountsAdd struct {
	AccountsAdd *AclAccountsAdd `protobuf:"bytes,11,opt,name=accountsAdd,proto3,oneof"`
}

type AclContentValue_RequestCancel struct {
	RequestCancel *AclAccountRequestCancel `protobuf:"bytes,12,opt,name=requestCancel,proto3,oneof"`
}

type AclContentValue_InviteJoin struct {
	InviteJoin *AclAccountInviteJoin `protobuf:"bytes,13,opt,name=inviteJoin,proto3,oneof"`
}

type AclContentValue_InviteChange struct {
	InviteChange *AclAccountInviteChange `protobuf:"bytes,14,opt,name=inviteChange,proto3,oneof"`
}

type AclContentValue_OwnershipChange struct {
	OwnershipChange *AclOwnershipChange `protobuf:"bytes,15,opt,name=ownershipChange,proto3,oneof"`
}

func (*AclContentValue_Invite) isAclContentValue_Value() {}

func (*AclContentValue_InviteRevoke) isAclContentValue_Value() {}

func (*AclContentValue_RequestJoin) isAclContentValue_Value() {}

func (*AclContentValue_RequestAccept) isAclContentValue_Value() {}

func (*AclContentValue_PermissionChange) isAclContentValue_Value() {}

func (*AclContentValue_AccountRemove) isAclContentValue_Value() {}

func (*AclContentValue_ReadKeyChange) isAclContentValue_Value() {}

func (*AclContentValue_RequestDecline) isAclContentValue_Value() {}

func (*AclContentValue_AccountRequestRemove) isAclContentValue_Value() {}

func (*AclContentValue_PermissionChanges) isAclContentValue_Value() {}

func (*AclContentValue_AccountsAdd) isAclContentValue_Value() {}

func (*AclContentValue_RequestCancel) isAclContentValue_Value() {}

func (*AclContentValue_InviteJoin) isAclContentValue_Value() {}

func (*AclContentValue_InviteChange) isAclContentValue_Value() {}

func (*AclContentValue_OwnershipChange) isAclContentValue_Value() {}

// AclData contains different acl content
type AclData struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	AclContent    []*AclContentValue     `protobuf:"bytes,1,rep,name=aclContent,proto3" json:"aclContent,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AclData) Reset() {
	*x = AclData{}
	mi := &file_aclrecord_proto_msgTypes[20]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AclData) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AclData) ProtoMessage() {}

func (x *AclData) ProtoReflect() protoreflect.Message {
	mi := &file_aclrecord_proto_msgTypes[20]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AclData.ProtoReflect.Descriptor instead.
func (*AclData) Descriptor() ([]byte, []int) {
	return file_aclrecord_proto_rawDescGZIP(), []int{20}
}

func (x *AclData) GetAclContent() []*AclContentValue {
	if x != nil {
		return x.AclContent
	}
	return nil
}

var File_aclrecord_proto protoreflect.FileDescriptor

const file_aclrecord_proto_rawDesc = "" +
	"\n" +
	"\x0faclrecord.proto\x12\taclrecord\"\xb1\x03\n" +
	"\aAclRoot\x12\x1a\n" +
	"\bidentity\x18\x01 \x01(\fR\bidentity\x12\x1c\n" +
	"\tmasterKey\x18\x02 \x01(\fR\tmasterKey\x12\x18\n" +
	"\aspaceId\x18\x03 \x01(\tR\aspaceId\x12*\n" +
	"\x10encryptedReadKey\x18\x04 \x01(\fR\x10encryptedReadKey\x12\x1c\n" +
	"\ttimestamp\x18\x05 \x01(\x03R\ttimestamp\x12,\n" +
	"\x11identitySignature\x18\x06 \x01(\fR\x11identitySignature\x12&\n" +
	"\x0emetadataPubKey\x18\a \x01(\fR\x0emetadataPubKey\x12:\n" +
	"\x18encryptedMetadataPrivKey\x18\b \x01(\fR\x18encryptedMetadataPrivKey\x126\n" +
	"\x16encryptedOwnerMetadata\x18\t \x01(\fR\x16encryptedOwnerMetadata\x12>\n" +
	"\foneToOneInfo\x18\n" +
	" \x01(\v2\x1a.aclrecord.AclOneToOneInfoR\foneToOneInfo\"A\n" +
	"\x0fAclOneToOneInfo\x12\x14\n" +
	"\x05owner\x18\x01 \x01(\fR\x05owner\x12\x18\n" +
	"\awriters\x18\x02 \x03(\fR\awriters\"\xd7\x01\n" +
	"\x10AclAccountInvite\x12\x1c\n" +
	"\tinviteKey\x18\x01 \x01(\fR\tinviteKey\x128\n" +
	"\n" +
	"inviteType\x18\x02 \x01(\x0e2\x18.aclrecord.AclInviteTypeR\n" +
	"inviteType\x12?\n" +
	"\vpermissions\x18\x03 \x01(\x0e2\x1d.aclrecord.AclUserPermissionsR\vpermissions\x12*\n" +
	"\x10encryptedReadKey\x18\x04 \x01(\fR\x10encryptedReadKey\"\x81\x01\n" +
	"\x16AclAccountInviteChange\x12&\n" +
	"\x0einviteRecordId\x18\x01 \x01(\tR\x0einviteRecordId\x12?\n" +
	"\vpermissions\x18\x02 \x01(\x0e2\x1d.aclrecord.AclUserPermissionsR\vpermissions\"\x91\x01\n" +
	"\x12AclOwnershipChange\x12*\n" +
	"\x10newOwnerIdentity\x18\x01 \x01(\fR\x10newOwnerIdentity\x12O\n" +
	"\x13oldOwnerPermissions\x18\x02 \x01(\x0e2\x1d.aclrecord.AclUserPermissionsR\x13oldOwnerPermissions\"\xbd\x01\n" +
	"\x15AclAccountRequestJoin\x12&\n" +
	"\x0einviteIdentity\x18\x01 \x01(\fR\x0einviteIdentity\x12&\n" +
	"\x0einviteRecordId\x18\x02 \x01(\tR\x0einviteRecordId\x128\n" +
	"\x17inviteIdentitySignature\x18\x03 \x01(\fR\x17inviteIdentitySignature\x12\x1a\n" +
	"\bmetadata\x18\x04 \x01(\fR\bmetadata\"\x9d\x02\n" +
	"\x14AclAccountInviteJoin\x12\x1a\n" +
	"\bidentity\x18\x01 \x01(\fR\bidentity\x12&\n" +
	"\x0einviteRecordId\x18\x02 \x01(\tR\x0einviteRecordId\x128\n" +
	"\x17inviteIdentitySignature\x18\x03 \x01(\fR\x17inviteIdentitySignature\x12\x1a\n" +
	"\bmetadata\x18\x04 \x01(\fR\bmetadata\x12*\n" +
	"\x10encryptedReadKey\x18\x05 \x01(\fR\x10encryptedReadKey\x12?\n" +
	"\vpermissions\x18\x06 \x01(\x0e2\x1d.aclrecord.AclUserPermissionsR\vpermissions\"\xcc\x01\n" +
	"\x17AclAccountRequestAccept\x12\x1a\n" +
	"\bidentity\x18\x01 \x01(\fR\bidentity\x12(\n" +
	"\x0frequestRecordId\x18\x02 \x01(\tR\x0frequestRecordId\x12*\n" +
	"\x10encryptedReadKey\x18\x03 \x01(\fR\x10encryptedReadKey\x12?\n" +
	"\vpermissions\x18\x04 \x01(\x0e2\x1d.aclrecord.AclUserPermissionsR\vpermissions\"D\n" +
	"\x18AclAccountRequestDecline\x12(\n" +
	"\x0frequestRecordId\x18\x01 \x01(\tR\x0frequestRecordId\"@\n" +
	"\x16AclAccountInviteRevoke\x12&\n" +
	"\x0einviteRecordId\x18\x01 \x01(\tR\x0einviteRecordId\"]\n" +
	"\x13AclEncryptedReadKey\x12\x1a\n" +
	"\bidentity\x18\x01 \x01(\fR\bidentity\x12*\n" +
	"\x10encryptedReadKey\x18\x02 \x01(\fR\x10encryptedReadKey\"^\n" +
	"\x1bAclAccountPermissionChanges\x12?\n" +
	"\achanges\x18\x01 \x03(\v2%.aclrecord.AclAccountPermissionChangeR\achanges\"H\n" +
	"\x0eAclAccountsAdd\x126\n" +
	"\tadditions\x18\x01 \x03(\v2\x18.aclrecord.AclAccountAddR\tadditions\"\xb4\x01\n" +
	"\rAclAccountAdd\x12\x1a\n" +
	"\bidentity\x18\x01 \x01(\fR\bidentity\x12?\n" +
	"\vpermissions\x18\x02 \x01(\x0e2\x1d.aclrecord.AclUserPermissionsR\vpermissions\x12\x1a\n" +
	"\bmetadata\x18\x03 \x01(\fR\bmetadata\x12*\n" +
	"\x10encryptedReadKey\x18\x04 \x01(\fR\x10encryptedReadKey\"5\n" +
	"\x17AclAccountRequestCancel\x12\x1a\n" +
	"\brecordId\x18\x01 \x01(\tR\brecordId\"y\n" +
	"\x1aAclAccountPermissionChange\x12\x1a\n" +
	"\bidentity\x18\x01 \x01(\fR\bidentity\x12?\n" +
	"\vpermissions\x18\x02 \x01(\x0e2\x1d.aclrecord.AclUserPermissionsR\vpermissions\"\xaa\x02\n" +
	"\x10AclReadKeyChange\x12@\n" +
	"\vaccountKeys\x18\x01 \x03(\v2\x1e.aclrecord.AclEncryptedReadKeyR\vaccountKeys\x12&\n" +
	"\x0emetadataPubKey\x18\x02 \x01(\fR\x0emetadataPubKey\x12:\n" +
	"\x18encryptedMetadataPrivKey\x18\x03 \x01(\fR\x18encryptedMetadataPrivKey\x120\n" +
	"\x13encryptedOldReadKey\x18\x04 \x01(\fR\x13encryptedOldReadKey\x12>\n" +
	"\n" +
	"inviteKeys\x18\x05 \x03(\v2\x1e.aclrecord.AclEncryptedReadKeyR\n" +
	"inviteKeys\"u\n" +
	"\x10AclAccountRemove\x12\x1e\n" +
	"\n" +
	"identities\x18\x01 \x03(\fR\n" +
	"identities\x12A\n" +
	"\rreadKeyChange\x18\x02 \x01(\v2\x1b.aclrecord.AclReadKeyChangeR\rreadKeyChange\"\x19\n" +
	"\x17AclAccountRequestRemove\"\xee\b\n" +
	"\x0fAclContentValue\x125\n" +
	"\x06invite\x18\x01 \x01(\v2\x1b.aclrecord.AclAccountInviteH\x00R\x06invite\x12G\n" +
	"\finviteRevoke\x18\x02 \x01(\v2!.aclrecord.AclAccountInviteRevokeH\x00R\finviteRevoke\x12D\n" +
	"\vrequestJoin\x18\x03 \x01(\v2 .aclrecord.AclAccountRequestJoinH\x00R\vrequestJoin\x12J\n" +
	"\rrequestAccept\x18\x04 \x01(\v2\".aclrecord.AclAccountRequestAcceptH\x00R\rrequestAccept\x12S\n" +
	"\x10permissionChange\x18\x05 \x01(\v2%.aclrecord.AclAccountPermissionChangeH\x00R\x10permissionChange\x12C\n" +
	"\raccountRemove\x18\x06 \x01(\v2\x1b.aclrecord.AclAccountRemoveH\x00R\raccountRemove\x12C\n" +
	"\rreadKeyChange\x18\a \x01(\v2\x1b.aclrecord.AclReadKeyChangeH\x00R\rreadKeyChange\x12M\n" +
	"\x0erequestDecline\x18\b \x01(\v2#.aclrecord.AclAccountRequestDeclineH\x00R\x0erequestDecline\x12X\n" +
	"\x14accountRequestRemove\x18\t \x01(\v2\".aclrecord.AclAccountRequestRemoveH\x00R\x14accountRequestRemove\x12V\n" +
	"\x11permissionChanges\x18\n" +
	" \x01(\v2&.aclrecord.AclAccountPermissionChangesH\x00R\x11permissionChanges\x12=\n" +
	"\vaccountsAdd\x18\v \x01(\v2\x19.aclrecord.AclAccountsAddH\x00R\vaccountsAdd\x12J\n" +
	"\rrequestCancel\x18\f \x01(\v2\".aclrecord.AclAccountRequestCancelH\x00R\rrequestCancel\x12A\n" +
	"\n" +
	"inviteJoin\x18\r \x01(\v2\x1f.aclrecord.AclAccountInviteJoinH\x00R\n" +
	"inviteJoin\x12G\n" +
	"\finviteChange\x18\x0e \x01(\v2!.aclrecord.AclAccountInviteChangeH\x00R\finviteChange\x12I\n" +
	"\x0fownershipChange\x18\x0f \x01(\v2\x1d.aclrecord.AclOwnershipChangeH\x00R\x0fownershipChangeB\a\n" +
	"\x05value\"E\n" +
	"\aAclData\x12:\n" +
	"\n" +
	"aclContent\x18\x01 \x03(\v2\x1a.aclrecord.AclContentValueR\n" +
	"aclContent*5\n" +
	"\rAclInviteType\x12\x11\n" +
	"\rRequestToJoin\x10\x00\x12\x11\n" +
	"\rAnyoneCanJoin\x10\x01*W\n" +
	"\x12AclUserPermissions\x12\b\n" +
	"\x04None\x10\x00\x12\t\n" +
	"\x05Owner\x10\x01\x12\t\n" +
	"\x05Admin\x10\x02\x12\n" +
	"\n" +
	"\x06Writer\x10\x03\x12\n" +
	"\n" +
	"\x06Reader\x10\x04\x12\t\n" +
	"\x05Guest\x10\x05B'Z%commonspace/object/acl/aclrecordprotob\x06proto3"

var (
	file_aclrecord_proto_rawDescOnce sync.Once
	file_aclrecord_proto_rawDescData []byte
)

func file_aclrecord_proto_rawDescGZIP() []byte {
	file_aclrecord_proto_rawDescOnce.Do(func() {
		file_aclrecord_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_aclrecord_proto_rawDesc), len(file_aclrecord_proto_rawDesc)))
	})
	return file_aclrecord_proto_rawDescData
}

var file_aclrecord_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
var file_aclrecord_proto_msgTypes = make([]protoimpl.MessageInfo, 21)
var file_aclrecord_proto_goTypes = []any{
	(AclInviteType)(0),                  // 0: aclrecord.AclInviteType
	(AclUserPermissions)(0),             // 1: aclrecord.AclUserPermissions
	(*AclRoot)(nil),                     // 2: aclrecord.AclRoot
	(*AclOneToOneInfo)(nil),             // 3: aclrecord.AclOneToOneInfo
	(*AclAccountInvite)(nil),            // 4: aclrecord.AclAccountInvite
	(*AclAccountInviteChange)(nil),      // 5: aclrecord.AclAccountInviteChange
	(*AclOwnershipChange)(nil),          // 6: aclrecord.AclOwnershipChange
	(*AclAccountRequestJoin)(nil),       // 7: aclrecord.AclAccountRequestJoin
	(*AclAccountInviteJoin)(nil),        // 8: aclrecord.AclAccountInviteJoin
	(*AclAccountRequestAccept)(nil),     // 9: aclrecord.AclAccountRequestAccept
	(*AclAccountRequestDecline)(nil),    // 10: aclrecord.AclAccountRequestDecline
	(*AclAccountInviteRevoke)(nil),      // 11: aclrecord.AclAccountInviteRevoke
	(*AclEncryptedReadKey)(nil),         // 12: aclrecord.AclEncryptedReadKey
	(*AclAccountPermissionChanges)(nil), // 13: aclrecord.AclAccountPermissionChanges
	(*AclAccountsAdd)(nil),              // 14: aclrecord.AclAccountsAdd
	(*AclAccountAdd)(nil),               // 15: aclrecord.AclAccountAdd
	(*AclAccountRequestCancel)(nil),     // 16: aclrecord.AclAccountRequestCancel
	(*AclAccountPermissionChange)(nil),  // 17: aclrecord.AclAccountPermissionChange
	(*AclReadKeyChange)(nil),            // 18: aclrecord.AclReadKeyChange
	(*AclAccountRemove)(nil),            // 19: aclrecord.AclAccountRemove
	(*AclAccountRequestRemove)(nil),     // 20: aclrecord.AclAccountRequestRemove
	(*AclContentValue)(nil),             // 21: aclrecord.AclContentValue
	(*AclData)(nil),                     // 22: aclrecord.AclData
}
var file_aclrecord_proto_depIdxs = []int32{
	3,  // 0: aclrecord.AclRoot.oneToOneInfo:type_name -> aclrecord.AclOneToOneInfo
	0,  // 1: aclrecord.AclAccountInvite.inviteType:type_name -> aclrecord.AclInviteType
	1,  // 2: aclrecord.AclAccountInvite.permissions:type_name -> aclrecord.AclUserPermissions
	1,  // 3: aclrecord.AclAccountInviteChange.permissions:type_name -> aclrecord.AclUserPermissions
	1,  // 4: aclrecord.AclOwnershipChange.oldOwnerPermissions:type_name -> aclrecord.AclUserPermissions
	1,  // 5: aclrecord.AclAccountInviteJoin.permissions:type_name -> aclrecord.AclUserPermissions
	1,  // 6: aclrecord.AclAccountRequestAccept.permissions:type_name -> aclrecord.AclUserPermissions
	17, // 7: aclrecord.AclAccountPermissionChanges.changes:type_name -> aclrecord.AclAccountPermissionChange
	15, // 8: aclrecord.AclAccountsAdd.additions:type_name -> aclrecord.AclAccountAdd
	1,  // 9: aclrecord.AclAccountAdd.permissions:type_name -> aclrecord.AclUserPermissions
	1,  // 10: aclrecord.AclAccountPermissionChange.permissions:type_name -> aclrecord.AclUserPermissions
	12, // 11: aclrecord.AclReadKeyChange.accountKeys:type_name -> aclrecord.AclEncryptedReadKey
	12, // 12: aclrecord.AclReadKeyChange.inviteKeys:type_name -> aclrecord.AclEncryptedReadKey
	18, // 13: aclrecord.AclAccountRemove.readKeyChange:type_name -> aclrecord.AclReadKeyChange
	4,  // 14: aclrecord.AclContentValue.invite:type_name -> aclrecord.AclAccountInvite
	11, // 15: aclrecord.AclContentValue.inviteRevoke:type_name -> aclrecord.AclAccountInviteRevoke
	7,  // 16: aclrecord.AclContentValue.requestJoin:type_name -> aclrecord.AclAccountRequestJoin
	9,  // 17: aclrecord.AclContentValue.requestAccept:type_name -> aclrecord.AclAccountRequestAccept
	17, // 18: aclrecord.AclContentValue.permissionChange:type_name -> aclrecord.AclAccountPermissionChange
	19, // 19: aclrecord.AclContentValue.accountRemove:type_name -> aclrecord.AclAccountRemove
	18, // 20: aclrecord.AclContentValue.readKeyChange:type_name -> aclrecord.AclReadKeyChange
	10, // 21: aclrecord.AclContentValue.requestDecline:type_name -> aclrecord.AclAccountRequestDecline
	20, // 22: aclrecord.AclContentValue.accountRequestRemove:type_name -> aclrecord.AclAccountRequestRemove
	13, // 23: aclrecord.AclContentValue.permissionChanges:type_name -> aclrecord.AclAccountPermissionChanges
	14, // 24: aclrecord.AclContentValue.accountsAdd:type_name -> aclrecord.AclAccountsAdd
	16, // 25: aclrecord.AclContentValue.requestCancel:type_name -> aclrecord.AclAccountRequestCancel
	8,  // 26: aclrecord.AclContentValue.inviteJoin:type_name -> aclrecord.AclAccountInviteJoin
	5,  // 27: aclrecord.AclContentValue.inviteChange:type_name -> aclrecord.AclAccountInviteChange
	6,  // 28: aclrecord.AclContentValue.ownershipChange:type_name -> aclrecord.AclOwnershipChange
	21, // 29: aclrecord.AclData.aclContent:type_name -> aclrecord.AclContentValue
	30, // [30:30] is the sub-list for method output_type
	30, // [30:30] is the sub-list for method input_type
	30, // [30:30] is the sub-list for extension type_name
	30, // [30:30] is the sub-list for extension extendee
	0,  // [0:30] is the sub-list for field type_name
}

func init() { file_aclrecord_proto_init() }
func file_aclrecord_proto_init() {
	if File_aclrecord_proto != nil {
		return
	}
	file_aclrecord_proto_msgTypes[19].OneofWrappers = []any{
		(*AclContentValue_Invite)(nil),
		(*AclContentValue_InviteRevoke)(nil),
		(*AclContentValue_RequestJoin)(nil),
		(*AclContentValue_RequestAccept)(nil),
		(*AclContentValue_PermissionChange)(nil),
		(*AclContentValue_AccountRemove)(nil),
		(*AclContentValue_ReadKeyChange)(nil),
		(*AclContentValue_RequestDecline)(nil),
		(*AclContentValue_AccountRequestRemove)(nil),
		(*AclContentValue_PermissionChanges)(nil),
		(*AclContentValue_AccountsAdd)(nil),
		(*AclContentValue_RequestCancel)(nil),
		(*AclContentValue_InviteJoin)(nil),
		(*AclContentValue_InviteChange)(nil),
		(*AclContentValue_OwnershipChange)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_aclrecord_proto_rawDesc), len(file_aclrecord_proto_rawDesc)),
			NumEnums:      2,
			NumMessages:   21,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_aclrecord_proto_goTypes,
		DependencyIndexes: file_aclrecord_proto_depIdxs,
		EnumInfos:         file_aclrecord_proto_enumTypes,
		MessageInfos:      file_aclrecord_proto_msgTypes,
	}.Build()
	File_aclrecord_proto = out.File
	file_aclrecord_proto_goTypes = nil
	file_aclrecord_proto_depIdxs = nil
}
