frostfs-api-go/v2/acl/grpc/types.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: v2/acl/grpc/types.proto

package acl

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	grpc "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
	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.ProtoPackageIsVersion3 // please upgrade the proto package

// Target of the access control rule in access control list.
type Target int32

const (
	// Unspecified target, default value.
	Target_TARGET_UNSPECIFIED Target = 0
	// User target rule is applied if sender is the owner of the container.
	Target_USER Target = 1
	// System target rule is applied if sender is the storage node within the
	// container or inner ring node.
	Target_SYSTEM Target = 2
	// Others target rule is applied if sender is not user or system target.
	Target_OTHERS Target = 3
)

var Target_name = map[int32]string{
	0: "TARGET_UNSPECIFIED",
	1: "USER",
	2: "SYSTEM",
	3: "OTHERS",
}

var Target_value = map[string]int32{
	"TARGET_UNSPECIFIED": 0,
	"USER":               1,
	"SYSTEM":             2,
	"OTHERS":             3,
}

func (x Target) String() string {
	return proto.EnumName(Target_name, int32(x))
}

func (Target) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8233b6696fb3e24f, []int{0}
}

// MatchType is an enumeration of match types.
type MatchType int32

const (
	// Unspecified match type, default value.
	MatchType_MATCH_TYPE_UNSPECIFIED MatchType = 0
	// Return true if strings are equal
	MatchType_STRING_EQUAL MatchType = 1
	// Return true if strings are different
	MatchType_STRING_NOT_EQUAL MatchType = 2
)

var MatchType_name = map[int32]string{
	0: "MATCH_TYPE_UNSPECIFIED",
	1: "STRING_EQUAL",
	2: "STRING_NOT_EQUAL",
}

var MatchType_value = map[string]int32{
	"MATCH_TYPE_UNSPECIFIED": 0,
	"STRING_EQUAL":           1,
	"STRING_NOT_EQUAL":       2,
}

func (x MatchType) String() string {
	return proto.EnumName(MatchType_name, int32(x))
}

func (MatchType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8233b6696fb3e24f, []int{1}
}

// Operation is an enumeration of operation types.
type Operation int32

const (
	// Unspecified operation, default value.
	Operation_OPERATION_UNSPECIFIED Operation = 0
	// Get
	Operation_GET Operation = 1
	// Head
	Operation_HEAD Operation = 2
	// Put
	Operation_PUT Operation = 3
	// Delete
	Operation_DELETE Operation = 4
	// Search
	Operation_SEARCH Operation = 5
	// GetRange
	Operation_GETRANGE Operation = 6
	// GetRangeHash
	Operation_GETRANGEHASH Operation = 7
)

var Operation_name = map[int32]string{
	0: "OPERATION_UNSPECIFIED",
	1: "GET",
	2: "HEAD",
	3: "PUT",
	4: "DELETE",
	5: "SEARCH",
	6: "GETRANGE",
	7: "GETRANGEHASH",
}

var Operation_value = map[string]int32{
	"OPERATION_UNSPECIFIED": 0,
	"GET":                   1,
	"HEAD":                  2,
	"PUT":                   3,
	"DELETE":                4,
	"SEARCH":                5,
	"GETRANGE":              6,
	"GETRANGEHASH":          7,
}

func (x Operation) String() string {
	return proto.EnumName(Operation_name, int32(x))
}

func (Operation) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8233b6696fb3e24f, []int{2}
}

// Action is an enumeration of EACL actions.
type Action int32

const (
	// Unspecified action, default value.
	Action_ACTION_UNSPECIFIED Action = 0
	// Allow action
	Action_ALLOW Action = 1
	// Deny action
	Action_DENY Action = 2
)

var Action_name = map[int32]string{
	0: "ACTION_UNSPECIFIED",
	1: "ALLOW",
	2: "DENY",
}

var Action_value = map[string]int32{
	"ACTION_UNSPECIFIED": 0,
	"ALLOW":              1,
	"DENY":               2,
}

func (x Action) String() string {
	return proto.EnumName(Action_name, int32(x))
}

func (Action) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8233b6696fb3e24f, []int{3}
}

// Header is an enumeration of filtering header types.
type HeaderType int32

const (
	// Unspecified header, default value.
	HeaderType_HEADER_UNSPECIFIED HeaderType = 0
	// Filter request headers
	HeaderType_REQUEST HeaderType = 1
	// Filter object headers
	HeaderType_OBJECT HeaderType = 2
)

var HeaderType_name = map[int32]string{
	0: "HEADER_UNSPECIFIED",
	1: "REQUEST",
	2: "OBJECT",
}

var HeaderType_value = map[string]int32{
	"HEADER_UNSPECIFIED": 0,
	"REQUEST":            1,
	"OBJECT":             2,
}

func (x HeaderType) String() string {
	return proto.EnumName(HeaderType_name, int32(x))
}

func (HeaderType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_8233b6696fb3e24f, []int{4}
}

// EACLRecord groups information about extended ACL rule.
type EACLRecord struct {
	// Operation carries type of operation.
	Operation Operation `protobuf:"varint,1,opt,name=operation,json=Operation,proto3,enum=neo.fs.v2.acl.Operation" json:"operation,omitempty"`
	// Action carries ACL target action.
	Action Action `protobuf:"varint,2,opt,name=action,json=Action,proto3,enum=neo.fs.v2.acl.Action" json:"action,omitempty"`
	// filters carries set of filters.
	Filters []*EACLRecord_FilterInfo `protobuf:"bytes,3,rep,name=filters,json=Filters,proto3" json:"filters,omitempty"`
	// targets carries information about extended ACL target list.
	Targets              []*EACLRecord_TargetInfo `protobuf:"bytes,4,rep,name=targets,json=Targets,proto3" json:"targets,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

func (m *EACLRecord) Reset()         { *m = EACLRecord{} }
func (m *EACLRecord) String() string { return proto.CompactTextString(m) }
func (*EACLRecord) ProtoMessage()    {}
func (*EACLRecord) Descriptor() ([]byte, []int) {
	return fileDescriptor_8233b6696fb3e24f, []int{0}
}
func (m *EACLRecord) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EACLRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EACLRecord.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 *EACLRecord) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EACLRecord.Merge(m, src)
}
func (m *EACLRecord) XXX_Size() int {
	return m.Size()
}
func (m *EACLRecord) XXX_DiscardUnknown() {
	xxx_messageInfo_EACLRecord.DiscardUnknown(m)
}

var xxx_messageInfo_EACLRecord proto.InternalMessageInfo

func (m *EACLRecord) GetOperation() Operation {
	if m != nil {
		return m.Operation
	}
	return Operation_OPERATION_UNSPECIFIED
}

func (m *EACLRecord) GetAction() Action {
	if m != nil {
		return m.Action
	}
	return Action_ACTION_UNSPECIFIED
}

func (m *EACLRecord) GetFilters() []*EACLRecord_FilterInfo {
	if m != nil {
		return m.Filters
	}
	return nil
}

func (m *EACLRecord) GetTargets() []*EACLRecord_TargetInfo {
	if m != nil {
		return m.Targets
	}
	return nil
}

// FilterInfo groups information about filter.
type EACLRecord_FilterInfo struct {
	// Header carries type of header.
	Header HeaderType `protobuf:"varint,1,opt,name=header,json=HeaderType,proto3,enum=neo.fs.v2.acl.HeaderType" json:"header,omitempty"`
	// MatchType carries type of match.
	MatchType MatchType `protobuf:"varint,2,opt,name=match_type,json=MatchType,proto3,enum=neo.fs.v2.acl.MatchType" json:"match_type,omitempty"`
	// header_name carries name of filtering header.
	HeaderName string `protobuf:"bytes,3,opt,name=header_name,json=Name,proto3" json:"header_name,omitempty"`
	// header_val carries value of filtering header.
	HeaderVal            string   `protobuf:"bytes,4,opt,name=header_val,json=Value,proto3" json:"header_val,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *EACLRecord_FilterInfo) Reset()         { *m = EACLRecord_FilterInfo{} }
func (m *EACLRecord_FilterInfo) String() string { return proto.CompactTextString(m) }
func (*EACLRecord_FilterInfo) ProtoMessage()    {}
func (*EACLRecord_FilterInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_8233b6696fb3e24f, []int{0, 0}
}
func (m *EACLRecord_FilterInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EACLRecord_FilterInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EACLRecord_FilterInfo.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 *EACLRecord_FilterInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EACLRecord_FilterInfo.Merge(m, src)
}
func (m *EACLRecord_FilterInfo) XXX_Size() int {
	return m.Size()
}
func (m *EACLRecord_FilterInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_EACLRecord_FilterInfo.DiscardUnknown(m)
}

var xxx_messageInfo_EACLRecord_FilterInfo proto.InternalMessageInfo

func (m *EACLRecord_FilterInfo) GetHeader() HeaderType {
	if m != nil {
		return m.Header
	}
	return HeaderType_HEADER_UNSPECIFIED
}

func (m *EACLRecord_FilterInfo) GetMatchType() MatchType {
	if m != nil {
		return m.MatchType
	}
	return MatchType_MATCH_TYPE_UNSPECIFIED
}

func (m *EACLRecord_FilterInfo) GetHeaderName() string {
	if m != nil {
		return m.HeaderName
	}
	return ""
}

func (m *EACLRecord_FilterInfo) GetHeaderVal() string {
	if m != nil {
		return m.HeaderVal
	}
	return ""
}

// TargetInfo groups information about extended ACL target.
type EACLRecord_TargetInfo struct {
	// target carries target of ACL rule.
	Target Target `protobuf:"varint,1,opt,name=target,json=Role,proto3,enum=neo.fs.v2.acl.Target" json:"target,omitempty"`
	// key_list carries public keys of ACL target.
	KeyList              [][]byte `protobuf:"bytes,2,rep,name=key_list,json=Keys,proto3" json:"key_list,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *EACLRecord_TargetInfo) Reset()         { *m = EACLRecord_TargetInfo{} }
func (m *EACLRecord_TargetInfo) String() string { return proto.CompactTextString(m) }
func (*EACLRecord_TargetInfo) ProtoMessage()    {}
func (*EACLRecord_TargetInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_8233b6696fb3e24f, []int{0, 1}
}
func (m *EACLRecord_TargetInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EACLRecord_TargetInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EACLRecord_TargetInfo.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 *EACLRecord_TargetInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EACLRecord_TargetInfo.Merge(m, src)
}
func (m *EACLRecord_TargetInfo) XXX_Size() int {
	return m.Size()
}
func (m *EACLRecord_TargetInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_EACLRecord_TargetInfo.DiscardUnknown(m)
}

var xxx_messageInfo_EACLRecord_TargetInfo proto.InternalMessageInfo

func (m *EACLRecord_TargetInfo) GetTarget() Target {
	if m != nil {
		return m.Target
	}
	return Target_TARGET_UNSPECIFIED
}

func (m *EACLRecord_TargetInfo) GetKeyList() [][]byte {
	if m != nil {
		return m.KeyList
	}
	return nil
}

// EACLRecord carries the information about extended ACL rules.
type EACLTable struct {
	// Carries identifier of the container that should use given
	// access control rules.
	ContainerId *grpc.ContainerID `protobuf:"bytes,1,opt,name=container_id,json=ContainerID,proto3" json:"container_id,omitempty"`
	// Records carries list of extended ACL rule records.
	Records              []*EACLRecord `protobuf:"bytes,2,rep,name=records,json=Records,proto3" json:"records,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *EACLTable) Reset()         { *m = EACLTable{} }
func (m *EACLTable) String() string { return proto.CompactTextString(m) }
func (*EACLTable) ProtoMessage()    {}
func (*EACLTable) Descriptor() ([]byte, []int) {
	return fileDescriptor_8233b6696fb3e24f, []int{1}
}
func (m *EACLTable) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EACLTable) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EACLTable.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 *EACLTable) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EACLTable.Merge(m, src)
}
func (m *EACLTable) XXX_Size() int {
	return m.Size()
}
func (m *EACLTable) XXX_DiscardUnknown() {
	xxx_messageInfo_EACLTable.DiscardUnknown(m)
}

var xxx_messageInfo_EACLTable proto.InternalMessageInfo

func (m *EACLTable) GetContainerId() *grpc.ContainerID {
	if m != nil {
		return m.ContainerId
	}
	return nil
}

func (m *EACLTable) GetRecords() []*EACLRecord {
	if m != nil {
		return m.Records
	}
	return nil
}

func init() {
	proto.RegisterEnum("neo.fs.v2.acl.Target", Target_name, Target_value)
	proto.RegisterEnum("neo.fs.v2.acl.MatchType", MatchType_name, MatchType_value)
	proto.RegisterEnum("neo.fs.v2.acl.Operation", Operation_name, Operation_value)
	proto.RegisterEnum("neo.fs.v2.acl.Action", Action_name, Action_value)
	proto.RegisterEnum("neo.fs.v2.acl.HeaderType", HeaderType_name, HeaderType_value)
	proto.RegisterType((*EACLRecord)(nil), "neo.fs.v2.acl.EACLRecord")
	proto.RegisterType((*EACLRecord_FilterInfo)(nil), "neo.fs.v2.acl.EACLRecord.FilterInfo")
	proto.RegisterType((*EACLRecord_TargetInfo)(nil), "neo.fs.v2.acl.EACLRecord.TargetInfo")
	proto.RegisterType((*EACLTable)(nil), "neo.fs.v2.acl.EACLTable")
}

func init() { proto.RegisterFile("v2/acl/grpc/types.proto", fileDescriptor_8233b6696fb3e24f) }

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

func (m *EACLRecord) 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 *EACLRecord) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EACLRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Targets) > 0 {
		for iNdEx := len(m.Targets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Targets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Filters) > 0 {
		for iNdEx := len(m.Filters) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Filters[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Action != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Action))
		i--
		dAtA[i] = 0x10
	}
	if m.Operation != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Operation))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EACLRecord_FilterInfo) 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 *EACLRecord_FilterInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EACLRecord_FilterInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.HeaderVal) > 0 {
		i -= len(m.HeaderVal)
		copy(dAtA[i:], m.HeaderVal)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.HeaderVal)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.HeaderName) > 0 {
		i -= len(m.HeaderName)
		copy(dAtA[i:], m.HeaderName)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.HeaderName)))
		i--
		dAtA[i] = 0x1a
	}
	if m.MatchType != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.MatchType))
		i--
		dAtA[i] = 0x10
	}
	if m.Header != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Header))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EACLRecord_TargetInfo) 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 *EACLRecord_TargetInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EACLRecord_TargetInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.KeyList) > 0 {
		for iNdEx := len(m.KeyList) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.KeyList[iNdEx])
			copy(dAtA[i:], m.KeyList[iNdEx])
			i = encodeVarintTypes(dAtA, i, uint64(len(m.KeyList[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Target != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Target))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *EACLTable) 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 *EACLTable) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func encodeVarintTypes(dAtA []byte, offset int, v uint64) int {
	offset -= sovTypes(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *EACLRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Operation != 0 {
		n += 1 + sovTypes(uint64(m.Operation))
	}
	if m.Action != 0 {
		n += 1 + sovTypes(uint64(m.Action))
	}
	if len(m.Filters) > 0 {
		for _, e := range m.Filters {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if len(m.Targets) > 0 {
		for _, e := range m.Targets {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *EACLRecord_FilterInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Header != 0 {
		n += 1 + sovTypes(uint64(m.Header))
	}
	if m.MatchType != 0 {
		n += 1 + sovTypes(uint64(m.MatchType))
	}
	l = len(m.HeaderName)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.HeaderVal)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *EACLRecord_TargetInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Target != 0 {
		n += 1 + sovTypes(uint64(m.Target))
	}
	if len(m.KeyList) > 0 {
		for _, b := range m.KeyList {
			l = len(b)
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *EACLTable) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ContainerId != nil {
		l = m.ContainerId.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	if len(m.Records) > 0 {
		for _, e := range m.Records {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovTypes(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozTypes(x uint64) (n int) {
	return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *EACLRecord) 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 ErrIntOverflowTypes
			}
			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: EACLRecord: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EACLRecord: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Operation", wireType)
			}
			m.Operation = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Operation |= Operation(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType)
			}
			m.Action = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Action |= Action(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Filters", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Filters = append(m.Filters, &EACLRecord_FilterInfo{})
			if err := m.Filters[len(m.Filters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Targets", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Targets = append(m.Targets, &EACLRecord_TargetInfo{})
			if err := m.Targets[len(m.Targets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EACLRecord_FilterInfo) 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 ErrIntOverflowTypes
			}
			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: FilterInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FilterInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
			}
			m.Header = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Header |= HeaderType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MatchType", wireType)
			}
			m.MatchType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MatchType |= MatchType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HeaderName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HeaderName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HeaderVal", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HeaderVal = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EACLRecord_TargetInfo) 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 ErrIntOverflowTypes
			}
			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: TargetInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TargetInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
			}
			m.Target = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Target |= Target(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeyList", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.KeyList = append(m.KeyList, make([]byte, postIndex-iNdEx))
			copy(m.KeyList[len(m.KeyList)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EACLTable) 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 ErrIntOverflowTypes
			}
			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: EACLTable: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EACLTable: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ContainerId == nil {
				m.ContainerId = &grpc.ContainerID{}
			}
			if err := m.ContainerId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Records", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Records = append(m.Records, &EACLRecord{})
			if err := m.Records[len(m.Records)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipTypes(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, ErrIntOverflowTypes
			}
			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, ErrIntOverflowTypes
				}
				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, ErrIntOverflowTypes
				}
				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, ErrInvalidLengthTypes
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupTypes
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthTypes
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthTypes        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTypes          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupTypes = fmt.Errorf("proto: unexpected end of group")
)