// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: commonspace/object/acl/aclrecordproto/protos/aclrecord.proto

package aclrecordproto

import (
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// 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
)

var AclUserPermissions_name = map[int32]string{
	0: "None",
	1: "Owner",
	2: "Admin",
	3: "Writer",
	4: "Reader",
}

var AclUserPermissions_value = map[string]int32{
	"None":   0,
	"Owner":  1,
	"Admin":  2,
	"Writer": 3,
	"Reader": 4,
}

func (x AclUserPermissions) String() string {
	return proto.EnumName(AclUserPermissions_name, int32(x))
}

func (AclUserPermissions) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_c8e9f754f34e929b, []int{0}
}

// AclRoot is a root of access control list
type AclRoot struct {
	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"`
}

func (m *AclRoot) Reset()         { *m = AclRoot{} }
func (m *AclRoot) String() string { return proto.CompactTextString(m) }
func (*AclRoot) ProtoMessage()    {}
func (*AclRoot) Descriptor() ([]byte, []int) {
	return fileDescriptor_c8e9f754f34e929b, []int{0}
}
func (m *AclRoot) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AclRoot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AclRoot.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AclRoot) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AclRoot.Merge(m, src)
}
func (m *AclRoot) XXX_Size() int {
	return m.Size()
}
func (m *AclRoot) XXX_DiscardUnknown() {
	xxx_messageInfo_AclRoot.DiscardUnknown(m)
}

var xxx_messageInfo_AclRoot proto.InternalMessageInfo

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

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

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

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

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

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

// AclAccountInvite contains the public invite key, the private part of which is sent to the user directly
type AclAccountInvite struct {
	InviteKey []byte `protobuf:"bytes,1,opt,name=inviteKey,proto3" json:"inviteKey,omitempty"`
}

func (m *AclAccountInvite) Reset()         { *m = AclAccountInvite{} }
func (m *AclAccountInvite) String() string { return proto.CompactTextString(m) }
func (*AclAccountInvite) ProtoMessage()    {}
func (*AclAccountInvite) Descriptor() ([]byte, []int) {
	return fileDescriptor_c8e9f754f34e929b, []int{1}
}
func (m *AclAccountInvite) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AclAccountInvite) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AclAccountInvite.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AclAccountInvite) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AclAccountInvite.Merge(m, src)
}
func (m *AclAccountInvite) XXX_Size() int {
	return m.Size()
}
func (m *AclAccountInvite) XXX_DiscardUnknown() {
	xxx_messageInfo_AclAccountInvite.DiscardUnknown(m)
}

var xxx_messageInfo_AclAccountInvite proto.InternalMessageInfo

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

// 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 {
	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                []byte `protobuf:"bytes,4,opt,name=metadata,proto3" json:"metadata,omitempty"`
}

func (m *AclAccountRequestJoin) Reset()         { *m = AclAccountRequestJoin{} }
func (m *AclAccountRequestJoin) String() string { return proto.CompactTextString(m) }
func (*AclAccountRequestJoin) ProtoMessage()    {}
func (*AclAccountRequestJoin) Descriptor() ([]byte, []int) {
	return fileDescriptor_c8e9f754f34e929b, []int{2}
}
func (m *AclAccountRequestJoin) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AclAccountRequestJoin) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AclAccountRequestJoin.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AclAccountRequestJoin) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AclAccountRequestJoin.Merge(m, src)
}
func (m *AclAccountRequestJoin) XXX_Size() int {
	return m.Size()
}
func (m *AclAccountRequestJoin) XXX_DiscardUnknown() {
	xxx_messageInfo_AclAccountRequestJoin.DiscardUnknown(m)
}

var xxx_messageInfo_AclAccountRequestJoin proto.InternalMessageInfo

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

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

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

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

// AclAccountRequestAccept contains the reference to join record and all read keys, encrypted with the identity of the requestor
type AclAccountRequestAccept struct {
	Identity          []byte                  `protobuf:"bytes,1,opt,name=identity,proto3" json:"identity,omitempty"`
	RequestRecordId   string                  `protobuf:"bytes,2,opt,name=requestRecordId,proto3" json:"requestRecordId,omitempty"`
	EncryptedReadKeys []*AclReadKeyWithRecord `protobuf:"bytes,3,rep,name=encryptedReadKeys,proto3" json:"encryptedReadKeys,omitempty"`
	Permissions       AclUserPermissions      `protobuf:"varint,4,opt,name=permissions,proto3,enum=aclrecord.AclUserPermissions" json:"permissions,omitempty"`
}

func (m *AclAccountRequestAccept) Reset()         { *m = AclAccountRequestAccept{} }
func (m *AclAccountRequestAccept) String() string { return proto.CompactTextString(m) }
func (*AclAccountRequestAccept) ProtoMessage()    {}
func (*AclAccountRequestAccept) Descriptor() ([]byte, []int) {
	return fileDescriptor_c8e9f754f34e929b, []int{3}
}
func (m *AclAccountRequestAccept) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AclAccountRequestAccept) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AclAccountRequestAccept.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AclAccountRequestAccept) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AclAccountRequestAccept.Merge(m, src)
}
func (m *AclAccountRequestAccept) XXX_Size() int {
	return m.Size()
}
func (m *AclAccountRequestAccept) XXX_DiscardUnknown() {
	xxx_messageInfo_AclAccountRequestAccept.DiscardUnknown(m)
}

var xxx_messageInfo_AclAccountRequestAccept proto.InternalMessageInfo

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

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

func (m *AclAccountRequestAccept) GetEncryptedReadKeys() []*AclReadKeyWithRecord {
	if m != nil {
		return m.EncryptedReadKeys
	}
	return nil
}

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

// AclAccountRequestDecline contains the reference to join record
type AclAccountRequestDecline struct {
	RequestRecordId string `protobuf:"bytes,1,opt,name=requestRecordId,proto3" json:"requestRecordId,omitempty"`
}

func (m *AclAccountRequestDecline) Reset()         { *m = AclAccountRequestDecline{} }
func (m *AclAccountRequestDecline) String() string { return proto.CompactTextString(m) }
func (*AclAccountRequestDecline) ProtoMessage()    {}
func (*AclAccountRequestDecline) Descriptor() ([]byte, []int) {
	return fileDescriptor_c8e9f754f34e929b, []int{4}
}
func (m *AclAccountRequestDecline) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AclAccountRequestDecline) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AclAccountRequestDecline.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AclAccountRequestDecline) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AclAccountRequestDecline.Merge(m, src)
}
func (m *AclAccountRequestDecline) XXX_Size() int {
	return m.Size()
}
func (m *AclAccountRequestDecline) XXX_DiscardUnknown() {
	xxx_messageInfo_AclAccountRequestDecline.DiscardUnknown(m)
}

var xxx_messageInfo_AclAccountRequestDecline proto.InternalMessageInfo

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

// AclAccountInviteRevoke revokes the invite record
type AclAccountInviteRevoke struct {
	InviteRecordId string `protobuf:"bytes,1,opt,name=inviteRecordId,proto3" json:"inviteRecordId,omitempty"`
}

func (m *AclAccountInviteRevoke) Reset()         { *m = AclAccountInviteRevoke{} }
func (m *AclAccountInviteRevoke) String() string { return proto.CompactTextString(m) }
func (*AclAccountInviteRevoke) ProtoMessage()    {}
func (*AclAccountInviteRevoke) Descriptor() ([]byte, []int) {
	return fileDescriptor_c8e9f754f34e929b, []int{5}
}
func (m *AclAccountInviteRevoke) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AclAccountInviteRevoke) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AclAccountInviteRevoke.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AclAccountInviteRevoke) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AclAccountInviteRevoke.Merge(m, src)
}
func (m *AclAccountInviteRevoke) XXX_Size() int {
	return m.Size()
}
func (m *AclAccountInviteRevoke) XXX_DiscardUnknown() {
	xxx_messageInfo_AclAccountInviteRevoke.DiscardUnknown(m)
}

var xxx_messageInfo_AclAccountInviteRevoke proto.InternalMessageInfo

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

// AclReadKeys are a read key with record id
type AclReadKeyWithRecord struct {
	RecordId         string `protobuf:"bytes,1,opt,name=recordId,proto3" json:"recordId,omitempty"`
	EncryptedReadKey []byte `protobuf:"bytes,2,opt,name=encryptedReadKey,proto3" json:"encryptedReadKey,omitempty"`
}

func (m *AclReadKeyWithRecord) Reset()         { *m = AclReadKeyWithRecord{} }
func (m *AclReadKeyWithRecord) String() string { return proto.CompactTextString(m) }
func (*AclReadKeyWithRecord) ProtoMessage()    {}
func (*AclReadKeyWithRecord) Descriptor() ([]byte, []int) {
	return fileDescriptor_c8e9f754f34e929b, []int{6}
}
func (m *AclReadKeyWithRecord) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AclReadKeyWithRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AclReadKeyWithRecord.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AclReadKeyWithRecord) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AclReadKeyWithRecord.Merge(m, src)
}
func (m *AclReadKeyWithRecord) XXX_Size() int {
	return m.Size()
}
func (m *AclReadKeyWithRecord) XXX_DiscardUnknown() {
	xxx_messageInfo_AclReadKeyWithRecord.DiscardUnknown(m)
}

var xxx_messageInfo_AclReadKeyWithRecord proto.InternalMessageInfo

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

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

// AclEncryptedReadKeys are new key for specific identity
type AclEncryptedReadKey struct {
	Identity         []byte `protobuf:"bytes,1,opt,name=identity,proto3" json:"identity,omitempty"`
	EncryptedReadKey []byte `protobuf:"bytes,2,opt,name=encryptedReadKey,proto3" json:"encryptedReadKey,omitempty"`
}

func (m *AclEncryptedReadKey) Reset()         { *m = AclEncryptedReadKey{} }
func (m *AclEncryptedReadKey) String() string { return proto.CompactTextString(m) }
func (*AclEncryptedReadKey) ProtoMessage()    {}
func (*AclEncryptedReadKey) Descriptor() ([]byte, []int) {
	return fileDescriptor_c8e9f754f34e929b, []int{7}
}
func (m *AclEncryptedReadKey) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AclEncryptedReadKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AclEncryptedReadKey.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AclEncryptedReadKey) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AclEncryptedReadKey.Merge(m, src)
}
func (m *AclEncryptedReadKey) XXX_Size() int {
	return m.Size()
}
func (m *AclEncryptedReadKey) XXX_DiscardUnknown() {
	xxx_messageInfo_AclEncryptedReadKey.DiscardUnknown(m)
}

var xxx_messageInfo_AclEncryptedReadKey proto.InternalMessageInfo

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

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

// AclAccountPermissionChange changes permissions of specific account
type AclAccountPermissionChange struct {
	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"`
}

func (m *AclAccountPermissionChange) Reset()         { *m = AclAccountPermissionChange{} }
func (m *AclAccountPermissionChange) String() string { return proto.CompactTextString(m) }
func (*AclAccountPermissionChange) ProtoMessage()    {}
func (*AclAccountPermissionChange) Descriptor() ([]byte, []int) {
	return fileDescriptor_c8e9f754f34e929b, []int{8}
}
func (m *AclAccountPermissionChange) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AclAccountPermissionChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AclAccountPermissionChange.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AclAccountPermissionChange) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AclAccountPermissionChange.Merge(m, src)
}
func (m *AclAccountPermissionChange) XXX_Size() int {
	return m.Size()
}
func (m *AclAccountPermissionChange) XXX_DiscardUnknown() {
	xxx_messageInfo_AclAccountPermissionChange.DiscardUnknown(m)
}

var xxx_messageInfo_AclAccountPermissionChange proto.InternalMessageInfo

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

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

// AclReadKeyChange changes the key for a space
type AclReadKeyChange struct {
	AccountKeys []*AclEncryptedReadKey `protobuf:"bytes,1,rep,name=accountKeys,proto3" json:"accountKeys,omitempty"`
}

func (m *AclReadKeyChange) Reset()         { *m = AclReadKeyChange{} }
func (m *AclReadKeyChange) String() string { return proto.CompactTextString(m) }
func (*AclReadKeyChange) ProtoMessage()    {}
func (*AclReadKeyChange) Descriptor() ([]byte, []int) {
	return fileDescriptor_c8e9f754f34e929b, []int{9}
}
func (m *AclReadKeyChange) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AclReadKeyChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AclReadKeyChange.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AclReadKeyChange) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AclReadKeyChange.Merge(m, src)
}
func (m *AclReadKeyChange) XXX_Size() int {
	return m.Size()
}
func (m *AclReadKeyChange) XXX_DiscardUnknown() {
	xxx_messageInfo_AclReadKeyChange.DiscardUnknown(m)
}

var xxx_messageInfo_AclReadKeyChange proto.InternalMessageInfo

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

// AclAccountRemove removes an account and changes read key for space
type AclAccountRemove struct {
	Identities  [][]byte               `protobuf:"bytes,1,rep,name=identities,proto3" json:"identities,omitempty"`
	AccountKeys []*AclEncryptedReadKey `protobuf:"bytes,2,rep,name=accountKeys,proto3" json:"accountKeys,omitempty"`
}

func (m *AclAccountRemove) Reset()         { *m = AclAccountRemove{} }
func (m *AclAccountRemove) String() string { return proto.CompactTextString(m) }
func (*AclAccountRemove) ProtoMessage()    {}
func (*AclAccountRemove) Descriptor() ([]byte, []int) {
	return fileDescriptor_c8e9f754f34e929b, []int{10}
}
func (m *AclAccountRemove) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AclAccountRemove) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AclAccountRemove.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AclAccountRemove) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AclAccountRemove.Merge(m, src)
}
func (m *AclAccountRemove) XXX_Size() int {
	return m.Size()
}
func (m *AclAccountRemove) XXX_DiscardUnknown() {
	xxx_messageInfo_AclAccountRemove.DiscardUnknown(m)
}

var xxx_messageInfo_AclAccountRemove proto.InternalMessageInfo

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

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

// AclAccountRequestRemove adds a request to remove an account
type AclAccountRequestRemove struct {
}

func (m *AclAccountRequestRemove) Reset()         { *m = AclAccountRequestRemove{} }
func (m *AclAccountRequestRemove) String() string { return proto.CompactTextString(m) }
func (*AclAccountRequestRemove) ProtoMessage()    {}
func (*AclAccountRequestRemove) Descriptor() ([]byte, []int) {
	return fileDescriptor_c8e9f754f34e929b, []int{11}
}
func (m *AclAccountRequestRemove) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AclAccountRequestRemove) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AclAccountRequestRemove.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AclAccountRequestRemove) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AclAccountRequestRemove.Merge(m, src)
}
func (m *AclAccountRequestRemove) XXX_Size() int {
	return m.Size()
}
func (m *AclAccountRequestRemove) XXX_DiscardUnknown() {
	xxx_messageInfo_AclAccountRequestRemove.DiscardUnknown(m)
}

var xxx_messageInfo_AclAccountRequestRemove proto.InternalMessageInfo

// AclContentValue contains possible values for Acl
type AclContentValue struct {
	// 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
	Value isAclContentValue_Value `protobuf_oneof:"value"`
}

func (m *AclContentValue) Reset()         { *m = AclContentValue{} }
func (m *AclContentValue) String() string { return proto.CompactTextString(m) }
func (*AclContentValue) ProtoMessage()    {}
func (*AclContentValue) Descriptor() ([]byte, []int) {
	return fileDescriptor_c8e9f754f34e929b, []int{12}
}
func (m *AclContentValue) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AclContentValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AclContentValue.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AclContentValue) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AclContentValue.Merge(m, src)
}
func (m *AclContentValue) XXX_Size() int {
	return m.Size()
}
func (m *AclContentValue) XXX_DiscardUnknown() {
	xxx_messageInfo_AclContentValue.DiscardUnknown(m)
}

var xxx_messageInfo_AclContentValue proto.InternalMessageInfo

type isAclContentValue_Value interface {
	isAclContentValue_Value()
	MarshalTo([]byte) (int, error)
	Size() int
}

type AclContentValue_Invite struct {
	Invite *AclAccountInvite `protobuf:"bytes,1,opt,name=invite,proto3,oneof" json:"invite,omitempty"`
}
type AclContentValue_InviteRevoke struct {
	InviteRevoke *AclAccountInviteRevoke `protobuf:"bytes,2,opt,name=inviteRevoke,proto3,oneof" json:"inviteRevoke,omitempty"`
}
type AclContentValue_RequestJoin struct {
	RequestJoin *AclAccountRequestJoin `protobuf:"bytes,3,opt,name=requestJoin,proto3,oneof" json:"requestJoin,omitempty"`
}
type AclContentValue_RequestAccept struct {
	RequestAccept *AclAccountRequestAccept `protobuf:"bytes,4,opt,name=requestAccept,proto3,oneof" json:"requestAccept,omitempty"`
}
type AclContentValue_PermissionChange struct {
	PermissionChange *AclAccountPermissionChange `protobuf:"bytes,5,opt,name=permissionChange,proto3,oneof" json:"permissionChange,omitempty"`
}
type AclContentValue_AccountRemove struct {
	AccountRemove *AclAccountRemove `protobuf:"bytes,6,opt,name=accountRemove,proto3,oneof" json:"accountRemove,omitempty"`
}
type AclContentValue_ReadKeyChange struct {
	ReadKeyChange *AclReadKeyChange `protobuf:"bytes,7,opt,name=readKeyChange,proto3,oneof" json:"readKeyChange,omitempty"`
}
type AclContentValue_RequestDecline struct {
	RequestDecline *AclAccountRequestDecline `protobuf:"bytes,8,opt,name=requestDecline,proto3,oneof" json:"requestDecline,omitempty"`
}
type AclContentValue_AccountRequestRemove struct {
	AccountRequestRemove *AclAccountRequestRemove `protobuf:"bytes,9,opt,name=accountRequestRemove,proto3,oneof" json:"accountRequestRemove,omitempty"`
}

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 (m *AclContentValue) GetValue() isAclContentValue_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

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

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

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

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

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

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

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

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

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

// XXX_OneofWrappers is for the internal use of the proto package.
func (*AclContentValue) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*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),
	}
}

// AclData contains different acl content
type AclData struct {
	AclContent []*AclContentValue `protobuf:"bytes,1,rep,name=aclContent,proto3" json:"aclContent,omitempty"`
}

func (m *AclData) Reset()         { *m = AclData{} }
func (m *AclData) String() string { return proto.CompactTextString(m) }
func (*AclData) ProtoMessage()    {}
func (*AclData) Descriptor() ([]byte, []int) {
	return fileDescriptor_c8e9f754f34e929b, []int{13}
}
func (m *AclData) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AclData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AclData.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AclData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AclData.Merge(m, src)
}
func (m *AclData) XXX_Size() int {
	return m.Size()
}
func (m *AclData) XXX_DiscardUnknown() {
	xxx_messageInfo_AclData.DiscardUnknown(m)
}

var xxx_messageInfo_AclData proto.InternalMessageInfo

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

func init() {
	proto.RegisterEnum("aclrecord.AclUserPermissions", AclUserPermissions_name, AclUserPermissions_value)
	proto.RegisterType((*AclRoot)(nil), "aclrecord.AclRoot")
	proto.RegisterType((*AclAccountInvite)(nil), "aclrecord.AclAccountInvite")
	proto.RegisterType((*AclAccountRequestJoin)(nil), "aclrecord.AclAccountRequestJoin")
	proto.RegisterType((*AclAccountRequestAccept)(nil), "aclrecord.AclAccountRequestAccept")
	proto.RegisterType((*AclAccountRequestDecline)(nil), "aclrecord.AclAccountRequestDecline")
	proto.RegisterType((*AclAccountInviteRevoke)(nil), "aclrecord.AclAccountInviteRevoke")
	proto.RegisterType((*AclReadKeyWithRecord)(nil), "aclrecord.AclReadKeyWithRecord")
	proto.RegisterType((*AclEncryptedReadKey)(nil), "aclrecord.AclEncryptedReadKey")
	proto.RegisterType((*AclAccountPermissionChange)(nil), "aclrecord.AclAccountPermissionChange")
	proto.RegisterType((*AclReadKeyChange)(nil), "aclrecord.AclReadKeyChange")
	proto.RegisterType((*AclAccountRemove)(nil), "aclrecord.AclAccountRemove")
	proto.RegisterType((*AclAccountRequestRemove)(nil), "aclrecord.AclAccountRequestRemove")
	proto.RegisterType((*AclContentValue)(nil), "aclrecord.AclContentValue")
	proto.RegisterType((*AclData)(nil), "aclrecord.AclData")
}

func init() {
	proto.RegisterFile("commonspace/object/acl/aclrecordproto/protos/aclrecord.proto", fileDescriptor_c8e9f754f34e929b)
}

var fileDescriptor_c8e9f754f34e929b = []byte{
	// 835 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0x5f, 0x4f, 0xdb, 0x56,
	0x14, 0xb7, 0x13, 0x92, 0x90, 0x63, 0xfe, 0x98, 0x3b, 0x36, 0x3c, 0xb6, 0x79, 0x99, 0x27, 0xa6,
	0x08, 0x4d, 0x30, 0x65, 0x9a, 0x34, 0x4d, 0x93, 0x20, 0x10, 0xb4, 0x84, 0x8d, 0x6d, 0xba, 0x6c,
	0x63, 0xaa, 0xd4, 0x4a, 0x17, 0xfb, 0x08, 0xdc, 0xc6, 0x76, 0x7a, 0x7d, 0x93, 0x2a, 0xdf, 0xa2,
	0x1f, 0xa6, 0xaf, 0x7d, 0xef, 0x23, 0x2f, 0x95, 0xfa, 0x58, 0xc1, 0x07, 0xe8, 0x57, 0xa8, 0x7c,
	0x1d, 0xe2, 0x3f, 0x31, 0x69, 0x79, 0x80, 0xd8, 0xe7, 0x9e, 0xdf, 0xef, 0xfc, 0xfb, 0x9d, 0x9b,
	0xc0, 0xaf, 0x76, 0xe0, 0x79, 0x81, 0x1f, 0x0e, 0x98, 0x8d, 0xbb, 0xc1, 0xf9, 0x63, 0xb4, 0xc5,
	0x2e, 0xb3, 0xfb, 0xd1, 0x1f, 0x47, 0x3b, 0xe0, 0xce, 0x80, 0x07, 0x22, 0xd8, 0x95, 0xff, 0xc3,
	0xc4, 0xba, 0x23, 0x0d, 0xa4, 0x3e, 0x35, 0x58, 0xaf, 0x55, 0xa8, 0xb5, 0xed, 0x3e, 0x0d, 0x02,
	0x41, 0x36, 0x61, 0xd1, 0x75, 0xd0, 0x17, 0xae, 0x18, 0x1b, 0x6a, 0x43, 0x6d, 0x2e, 0xd1, 0xe9,
	0x3b, 0xf9, 0x12, 0xea, 0x1e, 0x0b, 0x05, 0xf2, 0xdf, 0x71, 0x6c, 0x94, 0xe4, 0x61, 0x62, 0x20,
	0x06, 0xd4, 0x64, 0x2a, 0x3d, 0xc7, 0x28, 0x37, 0xd4, 0x66, 0x9d, 0xde, 0xbe, 0x92, 0x6d, 0xd0,
	0xd1, 0xb7, 0xf9, 0x78, 0x20, 0xd0, 0xa1, 0xc8, 0x9c, 0x08, 0xbe, 0x20, 0xe1, 0x33, 0xf6, 0x28,
	0x86, 0x70, 0x3d, 0x0c, 0x05, 0xf3, 0x06, 0x46, 0xa5, 0xa1, 0x36, 0xcb, 0x34, 0x31, 0x90, 0xef,
	0x61, 0xed, 0x36, 0x9b, 0x53, 0xf7, 0xc2, 0x67, 0x62, 0xc8, 0xd1, 0xa8, 0x4a, 0xaa, 0xd9, 0x03,
	0xeb, 0x07, 0xd0, 0xdb, 0x76, 0xbf, 0x6d, 0xdb, 0xc1, 0xd0, 0x17, 0x3d, 0x7f, 0xe4, 0x0a, 0x8c,
	0xf8, 0x5d, 0xf9, 0x14, 0x25, 0x11, 0x17, 0x98, 0x18, 0xac, 0x97, 0x2a, 0x7c, 0x9a, 0x40, 0x28,
	0x3e, 0x1d, 0x62, 0x28, 0x8e, 0x03, 0xd7, 0x27, 0xdf, 0xc1, 0x4a, 0xec, 0xd6, 0xcb, 0x76, 0x27,
	0x67, 0x4d, 0xfc, 0xa8, 0xec, 0x6d, 0xcf, 0x91, 0x8d, 0xaa, 0xd3, 0x9c, 0x95, 0xfc, 0x0c, 0x1b,
	0x59, 0x64, 0x52, 0x4f, 0x59, 0x12, 0xdf, 0x75, 0x1c, 0x4d, 0xc8, 0x43, 0xc1, 0x1c, 0x26, 0xd8,
	0xa4, 0x8b, 0xd3, 0x77, 0xeb, 0x9d, 0x0a, 0x1b, 0x33, 0xf9, 0xb7, 0x6d, 0x1b, 0x07, 0xf3, 0x27,
	0xdb, 0x84, 0x55, 0x1e, 0x3b, 0xe7, 0xd2, 0xce, 0x9b, 0xc9, 0x09, 0xac, 0xe5, 0x67, 0x16, 0x1a,
	0xe5, 0x46, 0xb9, 0xa9, 0xb5, 0xbe, 0xde, 0x49, 0x34, 0x16, 0xc9, 0x29, 0x3e, 0x3d, 0x73, 0xc5,
	0x65, 0x8c, 0xa6, 0xb3, 0x48, 0xb2, 0x07, 0xda, 0x00, 0xb9, 0xe7, 0x86, 0xa1, 0x1b, 0xf8, 0xa1,
	0xac, 0x67, 0xa5, 0xf5, 0x55, 0x96, 0xe8, 0xdf, 0x10, 0xf9, 0xdf, 0x89, 0x13, 0x4d, 0x23, 0xac,
	0x0e, 0x18, 0x33, 0x05, 0x77, 0xd0, 0xee, 0xbb, 0x3e, 0x16, 0x55, 0xa5, 0x16, 0x56, 0x65, 0xed,
	0xc3, 0x67, 0x79, 0xa5, 0x50, 0x1c, 0x05, 0x4f, 0xb0, 0x60, 0x9e, 0x6a, 0xd1, 0x3c, 0xad, 0x47,
	0xb0, 0x5e, 0x54, 0x73, 0xd4, 0x75, 0x9e, 0x45, 0x4e, 0xdf, 0x0b, 0xf7, 0xa2, 0x54, 0xbc, 0x17,
	0xd6, 0x43, 0xf8, 0xa4, 0x6d, 0xf7, 0x8f, 0xf2, 0xeb, 0x32, 0x6f, 0xa8, 0xf7, 0xa1, 0x1f, 0xc3,
	0x66, 0xd2, 0x80, 0xa4, 0xd9, 0x87, 0x97, 0xcc, 0xbf, 0xc0, 0xb9, 0x51, 0x72, 0x13, 0x2c, 0xdd,
	0x7b, 0x82, 0xff, 0xc8, 0x2d, 0x9d, 0x24, 0x32, 0x09, 0xb8, 0x0f, 0x1a, 0x8b, 0x73, 0x91, 0xfa,
	0x52, 0xa5, 0xbe, 0xcc, 0x2c, 0x69, 0xbe, 0x17, 0x34, 0x0d, 0xb1, 0x44, 0x7a, 0xf7, 0x29, 0x7a,
	0xc1, 0x08, 0x89, 0x09, 0x30, 0x49, 0xdb, 0xc5, 0x98, 0x74, 0x89, 0xa6, 0x2c, 0xf9, 0xa8, 0xa5,
	0xfb, 0x47, 0xfd, 0xbc, 0x60, 0xfd, 0xe2, 0xe0, 0xd6, 0x8b, 0x0a, 0xac, 0xb6, 0xed, 0xfe, 0x61,
	0xe0, 0x0b, 0xf4, 0xc5, 0x7f, 0xac, 0x3f, 0x44, 0xf2, 0x13, 0x54, 0x63, 0x19, 0xc9, 0xae, 0x6a,
	0xad, 0x2f, 0xb2, 0xb1, 0x32, 0x7a, 0xec, 0x2a, 0x74, 0xe2, 0x4c, 0x7e, 0x83, 0x25, 0x37, 0xa5,
	0x51, 0xd9, 0x73, 0xad, 0xf5, 0xcd, 0x1c, 0x70, 0xec, 0xd8, 0x55, 0x68, 0x06, 0x48, 0x3a, 0xa0,
	0xf1, 0xe4, 0x8e, 0x93, 0x17, 0x8f, 0xd6, 0x6a, 0x14, 0xf2, 0xa4, 0xee, 0xc2, 0xae, 0x42, 0xd3,
	0x30, 0x72, 0x0c, 0xcb, 0x3c, 0x7d, 0xd3, 0xc8, 0x2d, 0xd6, 0x5a, 0xd6, 0x3c, 0x9e, 0xd8, 0xb3,
	0xab, 0xd0, 0x2c, 0x94, 0x9c, 0x82, 0x3e, 0xc8, 0xa9, 0x4f, 0x7e, 0x0b, 0x68, 0xad, 0xad, 0x42,
	0xba, 0xbc, 0x54, 0xbb, 0x0a, 0x9d, 0x21, 0x20, 0x87, 0xb0, 0xcc, 0xd2, 0x42, 0x90, 0xdf, 0x18,
	0x77, 0x75, 0x3b, 0x76, 0x89, 0x32, 0xcb, 0x60, 0x22, 0x12, 0x9e, 0xd6, 0xa8, 0x51, 0x2b, 0x22,
	0xc9, 0xc8, 0x38, 0x2e, 0x2f, 0xad, 0xeb, 0x13, 0x58, 0xe1, 0x99, 0x3b, 0xca, 0x58, 0x94, 0x2c,
	0xdf, 0xce, 0xeb, 0xd5, 0xc4, 0xb5, 0xab, 0xd0, 0x1c, 0x98, 0xfc, 0x0f, 0xeb, 0xac, 0x40, 0x6b,
	0x46, 0xfd, 0xc3, 0x03, 0x98, 0x96, 0x59, 0xc8, 0x70, 0x50, 0x83, 0xca, 0x28, 0x92, 0xa8, 0x75,
	0x24, 0x7f, 0x1a, 0x74, 0x98, 0x60, 0xe4, 0x17, 0x00, 0x36, 0x15, 0xf0, 0x64, 0x27, 0x37, 0xb3,
	0x31, 0xd2, 0xea, 0xa6, 0x29, 0xef, 0xed, 0x3f, 0x80, 0xcc, 0xde, 0x03, 0x64, 0x11, 0x16, 0xfe,
	0x0c, 0x7c, 0xd4, 0x15, 0x52, 0x87, 0xca, 0x5f, 0xcf, 0x7c, 0xe4, 0xba, 0x1a, 0x3d, 0xb6, 0x1d,
	0xcf, 0xf5, 0xf5, 0x12, 0x01, 0xa8, 0x9e, 0x71, 0x57, 0x20, 0xd7, 0xcb, 0xd1, 0x73, 0xd4, 0x5c,
	0xe4, 0xfa, 0xc2, 0xc1, 0xde, 0xab, 0x6b, 0x53, 0xbd, 0xba, 0x36, 0xd5, 0xb7, 0xd7, 0xa6, 0xfa,
	0xfc, 0xc6, 0x54, 0xae, 0x6e, 0x4c, 0xe5, 0xcd, 0x8d, 0xa9, 0x3c, 0xd8, 0xfa, 0xa8, 0xdf, 0x44,
	0xe7, 0x55, 0xf9, 0xf1, 0xe3, 0xfb, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd0, 0xe7, 0x8e, 0xa9, 0x43,
	0x09, 0x00, 0x00,
}

func (m *AclRoot) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AclRoot) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AclRoot) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.IdentitySignature) > 0 {
		i -= len(m.IdentitySignature)
		copy(dAtA[i:], m.IdentitySignature)
		i = encodeVarintAclrecord(dAtA, i, uint64(len(m.IdentitySignature)))
		i--
		dAtA[i] = 0x32
	}
	if m.Timestamp != 0 {
		i = encodeVarintAclrecord(dAtA, i, uint64(m.Timestamp))
		i--
		dAtA[i] = 0x28
	}
	if len(m.EncryptedReadKey) > 0 {
		i -= len(m.EncryptedReadKey)
		copy(dAtA[i:], m.EncryptedReadKey)
		i = encodeVarintAclrecord(dAtA, i, uint64(len(m.EncryptedReadKey)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.SpaceId) > 0 {
		i -= len(m.SpaceId)
		copy(dAtA[i:], m.SpaceId)
		i = encodeVarintAclrecord(dAtA, i, uint64(len(m.SpaceId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.MasterKey) > 0 {
		i -= len(m.MasterKey)
		copy(dAtA[i:], m.MasterKey)
		i = encodeVarintAclrecord(dAtA, i, uint64(len(m.MasterKey)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Identity) > 0 {
		i -= len(m.Identity)
		copy(dAtA[i:], m.Identity)
		i = encodeVarintAclrecord(dAtA, i, uint64(len(m.Identity)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AclAccountInvite) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AclAccountInvite) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AclAccountInvite) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.InviteKey) > 0 {
		i -= len(m.InviteKey)
		copy(dAtA[i:], m.InviteKey)
		i = encodeVarintAclrecord(dAtA, i, uint64(len(m.InviteKey)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AclAccountRequestJoin) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AclAccountRequestJoin) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AclAccountRequestJoin) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Metadata) > 0 {
		i -= len(m.Metadata)
		copy(dAtA[i:], m.Metadata)
		i = encodeVarintAclrecord(dAtA, i, uint64(len(m.Metadata)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.InviteIdentitySignature) > 0 {
		i -= len(m.InviteIdentitySignature)
		copy(dAtA[i:], m.InviteIdentitySignature)
		i = encodeVarintAclrecord(dAtA, i, uint64(len(m.InviteIdentitySignature)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.InviteRecordId) > 0 {
		i -= len(m.InviteRecordId)
		copy(dAtA[i:], m.InviteRecordId)
		i = encodeVarintAclrecord(dAtA, i, uint64(len(m.InviteRecordId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.InviteIdentity) > 0 {
		i -= len(m.InviteIdentity)
		copy(dAtA[i:], m.InviteIdentity)
		i = encodeVarintAclrecord(dAtA, i, uint64(len(m.InviteIdentity)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AclAccountRequestAccept) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AclAccountRequestAccept) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AclAccountRequestAccept) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Permissions != 0 {
		i = encodeVarintAclrecord(dAtA, i, uint64(m.Permissions))
		i--
		dAtA[i] = 0x20
	}
	if len(m.EncryptedReadKeys) > 0 {
		for iNdEx := len(m.EncryptedReadKeys) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.EncryptedReadKeys[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintAclrecord(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.RequestRecordId) > 0 {
		i -= len(m.RequestRecordId)
		copy(dAtA[i:], m.RequestRecordId)
		i = encodeVarintAclrecord(dAtA, i, uint64(len(m.RequestRecordId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Identity) > 0 {
		i -= len(m.Identity)
		copy(dAtA[i:], m.Identity)
		i = encodeVarintAclrecord(dAtA, i, uint64(len(m.Identity)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AclAccountRequestDecline) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AclAccountRequestDecline) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AclAccountRequestDecline) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RequestRecordId) > 0 {
		i -= len(m.RequestRecordId)
		copy(dAtA[i:], m.RequestRecordId)
		i = encodeVarintAclrecord(dAtA, i, uint64(len(m.RequestRecordId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AclAccountInviteRevoke) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AclAccountInviteRevoke) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AclAccountInviteRevoke) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.InviteRecordId) > 0 {
		i -= len(m.InviteRecordId)
		copy(dAtA[i:], m.InviteRecordId)
		i = encodeVarintAclrecord(dAtA, i, uint64(len(m.InviteRecordId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AclReadKeyWithRecord) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AclReadKeyWithRecord) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AclReadKeyWithRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.EncryptedReadKey) > 0 {
		i -= len(m.EncryptedReadKey)
		copy(dAtA[i:], m.EncryptedReadKey)
		i = encodeVarintAclrecord(dAtA, i, uint64(len(m.EncryptedReadKey)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.RecordId) > 0 {
		i -= len(m.RecordId)
		copy(dAtA[i:], m.RecordId)
		i = encodeVarintAclrecord(dAtA, i, uint64(len(m.RecordId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AclEncryptedReadKey) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AclEncryptedReadKey) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AclEncryptedReadKey) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.EncryptedReadKey) > 0 {
		i -= len(m.EncryptedReadKey)
		copy(dAtA[i:], m.EncryptedReadKey)
		i = encodeVarintAclrecord(dAtA, i, uint64(len(m.EncryptedReadKey)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Identity) > 0 {
		i -= len(m.Identity)
		copy(dAtA[i:], m.Identity)
		i = encodeVarintAclrecord(dAtA, i, uint64(len(m.Identity)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AclAccountPermissionChange) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AclAccountPermissionChange) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AclAccountPermissionChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Permissions != 0 {
		i = encodeVarintAclrecord(dAtA, i, uint64(m.Permissions))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Identity) > 0 {
		i -= len(m.Identity)
		copy(dAtA[i:], m.Identity)
		i = encodeVarintAclrecord(dAtA, i, uint64(len(m.Identity)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AclReadKeyChange) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AclReadKeyChange) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AclReadKeyChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.AccountKeys) > 0 {
		for iNdEx := len(m.AccountKeys) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.AccountKeys[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintAclrecord(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *AclAccountRemove) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AclAccountRemove) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AclAccountRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.AccountKeys) > 0 {
		for iNdEx := len(m.AccountKeys) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.AccountKeys[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintAclrecord(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Identities) > 0 {
		for iNdEx := len(m.Identities) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Identities[iNdEx])
			copy(dAtA[i:], m.Identities[iNdEx])
			i = encodeVarintAclrecord(dAtA, i, uint64(len(m.Identities[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *AclAccountRequestRemove) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AclAccountRequestRemove) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AclAccountRequestRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *AclContentValue) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AclContentValue) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AclContentValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != nil {
		{
			size := m.Value.Size()
			i -= size
			if _, err := m.Value.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *AclContentValue_Invite) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AclContentValue_Invite) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Invite != nil {
		{
			size, err := m.Invite.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAclrecord(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *AclContentValue_InviteRevoke) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AclContentValue_InviteRevoke) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.InviteRevoke != nil {
		{
			size, err := m.InviteRevoke.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAclrecord(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *AclContentValue_RequestJoin) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AclContentValue_RequestJoin) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RequestJoin != nil {
		{
			size, err := m.RequestJoin.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAclrecord(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *AclContentValue_RequestAccept) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AclContentValue_RequestAccept) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RequestAccept != nil {
		{
			size, err := m.RequestAccept.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAclrecord(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *AclContentValue_PermissionChange) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AclContentValue_PermissionChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.PermissionChange != nil {
		{
			size, err := m.PermissionChange.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAclrecord(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *AclContentValue_AccountRemove) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AclContentValue_AccountRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.AccountRemove != nil {
		{
			size, err := m.AccountRemove.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAclrecord(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	return len(dAtA) - i, nil
}
func (m *AclContentValue_ReadKeyChange) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AclContentValue_ReadKeyChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ReadKeyChange != nil {
		{
			size, err := m.ReadKeyChange.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAclrecord(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	return len(dAtA) - i, nil
}
func (m *AclContentValue_RequestDecline) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AclContentValue_RequestDecline) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.RequestDecline != nil {
		{
			size, err := m.RequestDecline.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAclrecord(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	return len(dAtA) - i, nil
}
func (m *AclContentValue_AccountRequestRemove) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AclContentValue_AccountRequestRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.AccountRequestRemove != nil {
		{
			size, err := m.AccountRequestRemove.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAclrecord(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	return len(dAtA) - i, nil
}
func (m *AclData) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AclData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AclData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.AclContent) > 0 {
		for iNdEx := len(m.AclContent) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.AclContent[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintAclrecord(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func encodeVarintAclrecord(dAtA []byte, offset int, v uint64) int {
	offset -= sovAclrecord(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *AclRoot) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Identity)
	if l > 0 {
		n += 1 + l + sovAclrecord(uint64(l))
	}
	l = len(m.MasterKey)
	if l > 0 {
		n += 1 + l + sovAclrecord(uint64(l))
	}
	l = len(m.SpaceId)
	if l > 0 {
		n += 1 + l + sovAclrecord(uint64(l))
	}
	l = len(m.EncryptedReadKey)
	if l > 0 {
		n += 1 + l + sovAclrecord(uint64(l))
	}
	if m.Timestamp != 0 {
		n += 1 + sovAclrecord(uint64(m.Timestamp))
	}
	l = len(m.IdentitySignature)
	if l > 0 {
		n += 1 + l + sovAclrecord(uint64(l))
	}
	return n
}

func (m *AclAccountInvite) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.InviteKey)
	if l > 0 {
		n += 1 + l + sovAclrecord(uint64(l))
	}
	return n
}

func (m *AclAccountRequestJoin) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.InviteIdentity)
	if l > 0 {
		n += 1 + l + sovAclrecord(uint64(l))
	}
	l = len(m.InviteRecordId)
	if l > 0 {
		n += 1 + l + sovAclrecord(uint64(l))
	}
	l = len(m.InviteIdentitySignature)
	if l > 0 {
		n += 1 + l + sovAclrecord(uint64(l))
	}
	l = len(m.Metadata)
	if l > 0 {
		n += 1 + l + sovAclrecord(uint64(l))
	}
	return n
}

func (m *AclAccountRequestAccept) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Identity)
	if l > 0 {
		n += 1 + l + sovAclrecord(uint64(l))
	}
	l = len(m.RequestRecordId)
	if l > 0 {
		n += 1 + l + sovAclrecord(uint64(l))
	}
	if len(m.EncryptedReadKeys) > 0 {
		for _, e := range m.EncryptedReadKeys {
			l = e.Size()
			n += 1 + l + sovAclrecord(uint64(l))
		}
	}
	if m.Permissions != 0 {
		n += 1 + sovAclrecord(uint64(m.Permissions))
	}
	return n
}

func (m *AclAccountRequestDecline) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RequestRecordId)
	if l > 0 {
		n += 1 + l + sovAclrecord(uint64(l))
	}
	return n
}

func (m *AclAccountInviteRevoke) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.InviteRecordId)
	if l > 0 {
		n += 1 + l + sovAclrecord(uint64(l))
	}
	return n
}

func (m *AclReadKeyWithRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RecordId)
	if l > 0 {
		n += 1 + l + sovAclrecord(uint64(l))
	}
	l = len(m.EncryptedReadKey)
	if l > 0 {
		n += 1 + l + sovAclrecord(uint64(l))
	}
	return n
}

func (m *AclEncryptedReadKey) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Identity)
	if l > 0 {
		n += 1 + l + sovAclrecord(uint64(l))
	}
	l = len(m.EncryptedReadKey)
	if l > 0 {
		n += 1 + l + sovAclrecord(uint64(l))
	}
	return n
}

func (m *AclAccountPermissionChange) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Identity)
	if l > 0 {
		n += 1 + l + sovAclrecord(uint64(l))
	}
	if m.Permissions != 0 {
		n += 1 + sovAclrecord(uint64(m.Permissions))
	}
	return n
}

func (m *AclReadKeyChange) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.AccountKeys) > 0 {
		for _, e := range m.AccountKeys {
			l = e.Size()
			n += 1 + l + sovAclrecord(uint64(l))
		}
	}
	return n
}

func (m *AclAccountRemove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Identities) > 0 {
		for _, b := range m.Identities {
			l = len(b)
			n += 1 + l + sovAclrecord(uint64(l))
		}
	}
	if len(m.AccountKeys) > 0 {
		for _, e := range m.AccountKeys {
			l = e.Size()
			n += 1 + l + sovAclrecord(uint64(l))
		}
	}
	return n
}

func (m *AclAccountRequestRemove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *AclContentValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != nil {
		n += m.Value.Size()
	}
	return n
}

func (m *AclContentValue_Invite) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Invite != nil {
		l = m.Invite.Size()
		n += 1 + l + sovAclrecord(uint64(l))
	}
	return n
}
func (m *AclContentValue_InviteRevoke) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.InviteRevoke != nil {
		l = m.InviteRevoke.Size()
		n += 1 + l + sovAclrecord(uint64(l))
	}
	return n
}
func (m *AclContentValue_RequestJoin) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequestJoin != nil {
		l = m.RequestJoin.Size()
		n += 1 + l + sovAclrecord(uint64(l))
	}
	return n
}
func (m *AclContentValue_RequestAccept) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequestAccept != nil {
		l = m.RequestAccept.Size()
		n += 1 + l + sovAclrecord(uint64(l))
	}
	return n
}
func (m *AclContentValue_PermissionChange) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PermissionChange != nil {
		l = m.PermissionChange.Size()
		n += 1 + l + sovAclrecord(uint64(l))
	}
	return n
}
func (m *AclContentValue_AccountRemove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AccountRemove != nil {
		l = m.AccountRemove.Size()
		n += 1 + l + sovAclrecord(uint64(l))
	}
	return n
}
func (m *AclContentValue_ReadKeyChange) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ReadKeyChange != nil {
		l = m.ReadKeyChange.Size()
		n += 1 + l + sovAclrecord(uint64(l))
	}
	return n
}
func (m *AclContentValue_RequestDecline) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequestDecline != nil {
		l = m.RequestDecline.Size()
		n += 1 + l + sovAclrecord(uint64(l))
	}
	return n
}
func (m *AclContentValue_AccountRequestRemove) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AccountRequestRemove != nil {
		l = m.AccountRequestRemove.Size()
		n += 1 + l + sovAclrecord(uint64(l))
	}
	return n
}
func (m *AclData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.AclContent) > 0 {
		for _, e := range m.AclContent {
			l = e.Size()
			n += 1 + l + sovAclrecord(uint64(l))
		}
	}
	return n
}

func sovAclrecord(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozAclrecord(x uint64) (n int) {
	return sovAclrecord(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *AclRoot) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAclrecord
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AclRoot: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AclRoot: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Identity = append(m.Identity[:0], dAtA[iNdEx:postIndex]...)
			if m.Identity == nil {
				m.Identity = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MasterKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MasterKey = append(m.MasterKey[:0], dAtA[iNdEx:postIndex]...)
			if m.MasterKey == nil {
				m.MasterKey = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpaceId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SpaceId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EncryptedReadKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EncryptedReadKey = append(m.EncryptedReadKey[:0], dAtA[iNdEx:postIndex]...)
			if m.EncryptedReadKey == nil {
				m.EncryptedReadKey = []byte{}
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			m.Timestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Timestamp |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IdentitySignature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IdentitySignature = append(m.IdentitySignature[:0], dAtA[iNdEx:postIndex]...)
			if m.IdentitySignature == nil {
				m.IdentitySignature = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAclrecord(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAclrecord
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AclAccountInvite) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAclrecord
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AclAccountInvite: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AclAccountInvite: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InviteKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InviteKey = append(m.InviteKey[:0], dAtA[iNdEx:postIndex]...)
			if m.InviteKey == nil {
				m.InviteKey = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAclrecord(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAclrecord
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AclAccountRequestJoin) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAclrecord
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AclAccountRequestJoin: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AclAccountRequestJoin: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InviteIdentity", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InviteIdentity = append(m.InviteIdentity[:0], dAtA[iNdEx:postIndex]...)
			if m.InviteIdentity == nil {
				m.InviteIdentity = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InviteRecordId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InviteRecordId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InviteIdentitySignature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InviteIdentitySignature = append(m.InviteIdentitySignature[:0], dAtA[iNdEx:postIndex]...)
			if m.InviteIdentitySignature == nil {
				m.InviteIdentitySignature = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Metadata = append(m.Metadata[:0], dAtA[iNdEx:postIndex]...)
			if m.Metadata == nil {
				m.Metadata = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAclrecord(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAclrecord
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AclAccountRequestAccept) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAclrecord
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AclAccountRequestAccept: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AclAccountRequestAccept: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Identity = append(m.Identity[:0], dAtA[iNdEx:postIndex]...)
			if m.Identity == nil {
				m.Identity = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestRecordId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RequestRecordId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EncryptedReadKeys", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EncryptedReadKeys = append(m.EncryptedReadKeys, &AclReadKeyWithRecord{})
			if err := m.EncryptedReadKeys[len(m.EncryptedReadKeys)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Permissions", wireType)
			}
			m.Permissions = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Permissions |= AclUserPermissions(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipAclrecord(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAclrecord
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AclAccountRequestDecline) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAclrecord
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AclAccountRequestDecline: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AclAccountRequestDecline: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestRecordId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RequestRecordId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAclrecord(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAclrecord
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AclAccountInviteRevoke) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAclrecord
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AclAccountInviteRevoke: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AclAccountInviteRevoke: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InviteRecordId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InviteRecordId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAclrecord(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAclrecord
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AclReadKeyWithRecord) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAclrecord
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AclReadKeyWithRecord: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AclReadKeyWithRecord: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecordId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RecordId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EncryptedReadKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EncryptedReadKey = append(m.EncryptedReadKey[:0], dAtA[iNdEx:postIndex]...)
			if m.EncryptedReadKey == nil {
				m.EncryptedReadKey = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAclrecord(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAclrecord
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AclEncryptedReadKey) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAclrecord
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AclEncryptedReadKey: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AclEncryptedReadKey: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Identity = append(m.Identity[:0], dAtA[iNdEx:postIndex]...)
			if m.Identity == nil {
				m.Identity = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EncryptedReadKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EncryptedReadKey = append(m.EncryptedReadKey[:0], dAtA[iNdEx:postIndex]...)
			if m.EncryptedReadKey == nil {
				m.EncryptedReadKey = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAclrecord(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAclrecord
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AclAccountPermissionChange) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAclrecord
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AclAccountPermissionChange: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AclAccountPermissionChange: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Identity = append(m.Identity[:0], dAtA[iNdEx:postIndex]...)
			if m.Identity == nil {
				m.Identity = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Permissions", wireType)
			}
			m.Permissions = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Permissions |= AclUserPermissions(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipAclrecord(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAclrecord
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AclReadKeyChange) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAclrecord
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AclReadKeyChange: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AclReadKeyChange: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccountKeys", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AccountKeys = append(m.AccountKeys, &AclEncryptedReadKey{})
			if err := m.AccountKeys[len(m.AccountKeys)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAclrecord(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAclrecord
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AclAccountRemove) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAclrecord
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AclAccountRemove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AclAccountRemove: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Identities", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Identities = append(m.Identities, make([]byte, postIndex-iNdEx))
			copy(m.Identities[len(m.Identities)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccountKeys", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AccountKeys = append(m.AccountKeys, &AclEncryptedReadKey{})
			if err := m.AccountKeys[len(m.AccountKeys)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAclrecord(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAclrecord
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AclAccountRequestRemove) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAclrecord
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AclAccountRequestRemove: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AclAccountRequestRemove: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipAclrecord(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAclrecord
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AclContentValue) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAclrecord
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AclContentValue: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AclContentValue: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Invite", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &AclAccountInvite{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &AclContentValue_Invite{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InviteRevoke", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &AclAccountInviteRevoke{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &AclContentValue_InviteRevoke{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestJoin", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &AclAccountRequestJoin{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &AclContentValue_RequestJoin{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestAccept", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &AclAccountRequestAccept{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &AclContentValue_RequestAccept{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PermissionChange", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &AclAccountPermissionChange{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &AclContentValue_PermissionChange{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccountRemove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &AclAccountRemove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &AclContentValue_AccountRemove{v}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReadKeyChange", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &AclReadKeyChange{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &AclContentValue_ReadKeyChange{v}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestDecline", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &AclAccountRequestDecline{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &AclContentValue_RequestDecline{v}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccountRequestRemove", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &AclAccountRequestRemove{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &AclContentValue_AccountRequestRemove{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAclrecord(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAclrecord
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AclData) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAclrecord
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AclData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AclData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AclContent", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAclrecord
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAclrecord
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AclContent = append(m.AclContent, &AclContentValue{})
			if err := m.AclContent[len(m.AclContent)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAclrecord(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAclrecord
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipAclrecord(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowAclrecord
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowAclrecord
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthAclrecord
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupAclrecord
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthAclrecord
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthAclrecord        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowAclrecord          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupAclrecord = fmt.Errorf("proto: unexpected end of group")
)