// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.11
// 	protoc        v7.36.1
// source: acl.proto

package acl

import (
	common "github.com/easytier/easytier/easytier-go/proto/common"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

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

// Enhanced protocol enum with more granular options
type Protocol int32

const (
	Protocol_Unspecified Protocol = 0
	Protocol_TCP         Protocol = 1
	Protocol_UDP         Protocol = 2
	Protocol_ICMP        Protocol = 3
	Protocol_ICMPv6      Protocol = 4
	Protocol_Any         Protocol = 5
)

// Enum value maps for Protocol.
var (
	Protocol_name = map[int32]string{
		0: "Unspecified",
		1: "TCP",
		2: "UDP",
		3: "ICMP",
		4: "ICMPv6",
		5: "Any",
	}
	Protocol_value = map[string]int32{
		"Unspecified": 0,
		"TCP":         1,
		"UDP":         2,
		"ICMP":        3,
		"ICMPv6":      4,
		"Any":         5,
	}
)

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

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

func (Protocol) Descriptor() protoreflect.EnumDescriptor {
	return file_acl_proto_enumTypes[0].Descriptor()
}

func (Protocol) Type() protoreflect.EnumType {
	return &file_acl_proto_enumTypes[0]
}

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

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

type Action int32

const (
	Action_Noop  Action = 0
	Action_Allow Action = 1
	Action_Drop  Action = 2 // Silent drop (no response)
)

// Enum value maps for Action.
var (
	Action_name = map[int32]string{
		0: "Noop",
		1: "Allow",
		2: "Drop",
	}
	Action_value = map[string]int32{
		"Noop":  0,
		"Allow": 1,
		"Drop":  2,
	}
)

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

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

func (Action) Descriptor() protoreflect.EnumDescriptor {
	return file_acl_proto_enumTypes[1].Descriptor()
}

func (Action) Type() protoreflect.EnumType {
	return &file_acl_proto_enumTypes[1]
}

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

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

type ChainType int32

const (
	ChainType_UnspecifiedChain ChainType = 0
	// send to this node
	ChainType_Inbound ChainType = 1
	// send from this node
	ChainType_Outbound ChainType = 2
	// subnet proxy
	ChainType_Forward ChainType = 3
)

// Enum value maps for ChainType.
var (
	ChainType_name = map[int32]string{
		0: "UnspecifiedChain",
		1: "Inbound",
		2: "Outbound",
		3: "Forward",
	}
	ChainType_value = map[string]int32{
		"UnspecifiedChain": 0,
		"Inbound":          1,
		"Outbound":         2,
		"Forward":          3,
	}
)

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

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

func (ChainType) Descriptor() protoreflect.EnumDescriptor {
	return file_acl_proto_enumTypes[2].Descriptor()
}

func (ChainType) Type() protoreflect.EnumType {
	return &file_acl_proto_enumTypes[2]
}

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

// Deprecated: Use ChainType.Descriptor instead.
func (ChainType) EnumDescriptor() ([]byte, []int) {
	return file_acl_proto_rawDescGZIP(), []int{2}
}

type ConnState int32

const (
	ConnState_New         ConnState = 0
	ConnState_Established ConnState = 1
	ConnState_Related     ConnState = 2
	ConnState_Invalid     ConnState = 3
)

// Enum value maps for ConnState.
var (
	ConnState_name = map[int32]string{
		0: "New",
		1: "Established",
		2: "Related",
		3: "Invalid",
	}
	ConnState_value = map[string]int32{
		"New":         0,
		"Established": 1,
		"Related":     2,
		"Invalid":     3,
	}
)

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

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

func (ConnState) Descriptor() protoreflect.EnumDescriptor {
	return file_acl_proto_enumTypes[3].Descriptor()
}

func (ConnState) Type() protoreflect.EnumType {
	return &file_acl_proto_enumTypes[3]
}

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

// Deprecated: Use ConnState.Descriptor instead.
func (ConnState) EnumDescriptor() ([]byte, []int) {
	return file_acl_proto_rawDescGZIP(), []int{3}
}

// Time-based access control
type TimeWindow struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Days of week: 0=Sunday, 1=Monday, ..., 6=Saturday
	DaysOfWeek []uint32 `protobuf:"varint,1,rep,packed,name=days_of_week,json=daysOfWeek,proto3" json:"days_of_week,omitempty"`
	// Time in minutes from midnight (0-1439)
	StartTime uint32 `protobuf:"varint,2,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
	EndTime   uint32 `protobuf:"varint,3,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"`
	// Timezone offset in minutes from UTC
	TimezoneOffset int32 `protobuf:"varint,4,opt,name=timezone_offset,json=timezoneOffset,proto3" json:"timezone_offset,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*TimeWindow) ProtoMessage() {}

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

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

func (x *TimeWindow) GetDaysOfWeek() []uint32 {
	if x != nil {
		return x.DaysOfWeek
	}
	return nil
}

func (x *TimeWindow) GetStartTime() uint32 {
	if x != nil {
		return x.StartTime
	}
	return 0
}

func (x *TimeWindow) GetEndTime() uint32 {
	if x != nil {
		return x.EndTime
	}
	return 0
}

func (x *TimeWindow) GetTimezoneOffset() int32 {
	if x != nil {
		return x.TimezoneOffset
	}
	return 0
}

// Enhanced rule with priority and metadata
type Rule struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Rule identification and metadata
	Name        string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`               // Human-readable rule name
	Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"` // Rule description
	Priority    uint32 `protobuf:"varint,3,opt,name=priority,proto3" json:"priority,omitempty"`      // Higher number = higher priority (0-65535)
	Enabled     bool   `protobuf:"varint,4,opt,name=enabled,proto3" json:"enabled,omitempty"`        // Rule enabled/disabled state
	// Core matching criteria
	Protocol       Protocol `protobuf:"varint,5,opt,name=protocol,proto3,enum=acl.Protocol" json:"protocol,omitempty"`
	Ports          []string `protobuf:"bytes,6,rep,name=ports,proto3" json:"ports,omitempty"`
	SourceIps      []string `protobuf:"bytes,7,rep,name=source_ips,json=sourceIps,proto3" json:"source_ips,omitempty"`                // Source IP ranges
	DestinationIps []string `protobuf:"bytes,8,rep,name=destination_ips,json=destinationIps,proto3" json:"destination_ips,omitempty"` // Destination IP ranges
	// Enhanced matching criteria
	SourcePorts []string `protobuf:"bytes,9,rep,name=source_ports,json=sourcePorts,proto3" json:"source_ports,omitempty"` // Source port range
	// Action and logging
	Action Action `protobuf:"varint,10,opt,name=action,proto3,enum=acl.Action" json:"action,omitempty"`
	// Rate limiting (packets per second)
	RateLimit  uint32 `protobuf:"varint,11,opt,name=rate_limit,json=rateLimit,proto3" json:"rate_limit,omitempty"`    // 0 = no limit
	BurstLimit uint32 `protobuf:"varint,12,opt,name=burst_limit,json=burstLimit,proto3" json:"burst_limit,omitempty"` // Burst allowance
	// Connection tracking
	Stateful bool `protobuf:"varint,13,opt,name=stateful,proto3" json:"stateful,omitempty"` // Enable connection tracking
	// Group matching criteria
	SourceGroups      []string `protobuf:"bytes,14,rep,name=source_groups,json=sourceGroups,proto3" json:"source_groups,omitempty"`
	DestinationGroups []string `protobuf:"bytes,15,rep,name=destination_groups,json=destinationGroups,proto3" json:"destination_groups,omitempty"`
	unknownFields     protoimpl.UnknownFields
	sizeCache         protoimpl.SizeCache
}

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

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

func (*Rule) ProtoMessage() {}

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

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

func (x *Rule) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *Rule) GetDescription() string {
	if x != nil {
		return x.Description
	}
	return ""
}

func (x *Rule) GetPriority() uint32 {
	if x != nil {
		return x.Priority
	}
	return 0
}

func (x *Rule) GetEnabled() bool {
	if x != nil {
		return x.Enabled
	}
	return false
}

func (x *Rule) GetProtocol() Protocol {
	if x != nil {
		return x.Protocol
	}
	return Protocol_Unspecified
}

func (x *Rule) GetPorts() []string {
	if x != nil {
		return x.Ports
	}
	return nil
}

func (x *Rule) GetSourceIps() []string {
	if x != nil {
		return x.SourceIps
	}
	return nil
}

func (x *Rule) GetDestinationIps() []string {
	if x != nil {
		return x.DestinationIps
	}
	return nil
}

func (x *Rule) GetSourcePorts() []string {
	if x != nil {
		return x.SourcePorts
	}
	return nil
}

func (x *Rule) GetAction() Action {
	if x != nil {
		return x.Action
	}
	return Action_Noop
}

func (x *Rule) GetRateLimit() uint32 {
	if x != nil {
		return x.RateLimit
	}
	return 0
}

func (x *Rule) GetBurstLimit() uint32 {
	if x != nil {
		return x.BurstLimit
	}
	return 0
}

func (x *Rule) GetStateful() bool {
	if x != nil {
		return x.Stateful
	}
	return false
}

func (x *Rule) GetSourceGroups() []string {
	if x != nil {
		return x.SourceGroups
	}
	return nil
}

func (x *Rule) GetDestinationGroups() []string {
	if x != nil {
		return x.DestinationGroups
	}
	return nil
}

// Rule chain with metadata and optimization hints
type Chain struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Chain identification
	Name        string    `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` // Human-readable chain name
	ChainType   ChainType `protobuf:"varint,2,opt,name=chain_type,json=chainType,proto3,enum=acl.ChainType" json:"chain_type,omitempty"`
	Description string    `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"` // Chain description
	Enabled     bool      `protobuf:"varint,4,opt,name=enabled,proto3" json:"enabled,omitempty"`        // Chain enabled/disabled state
	// Rules in priority order (highest priority first)
	Rules []*Rule `protobuf:"bytes,5,rep,name=rules,proto3" json:"rules,omitempty"`
	// Default action when no rules match
	DefaultAction Action `protobuf:"varint,6,opt,name=default_action,json=defaultAction,proto3,enum=acl.Action" json:"default_action,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Chain) ProtoMessage() {}

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

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

func (x *Chain) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *Chain) GetChainType() ChainType {
	if x != nil {
		return x.ChainType
	}
	return ChainType_UnspecifiedChain
}

func (x *Chain) GetDescription() string {
	if x != nil {
		return x.Description
	}
	return ""
}

func (x *Chain) GetEnabled() bool {
	if x != nil {
		return x.Enabled
	}
	return false
}

func (x *Chain) GetRules() []*Rule {
	if x != nil {
		return x.Rules
	}
	return nil
}

func (x *Chain) GetDefaultAction() Action {
	if x != nil {
		return x.DefaultAction
	}
	return Action_Noop
}

type GroupInfo struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Declares      []*GroupIdentity       `protobuf:"bytes,1,rep,name=declares,proto3" json:"declares,omitempty"`
	Members       []string               `protobuf:"bytes,2,rep,name=members,proto3" json:"members,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GroupInfo) ProtoMessage() {}

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

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

func (x *GroupInfo) GetDeclares() []*GroupIdentity {
	if x != nil {
		return x.Declares
	}
	return nil
}

func (x *GroupInfo) GetMembers() []string {
	if x != nil {
		return x.Members
	}
	return nil
}

type GroupIdentity struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	GroupName     string                 `protobuf:"bytes,1,opt,name=group_name,json=groupName,proto3" json:"group_name,omitempty"`
	GroupSecret   string                 `protobuf:"bytes,2,opt,name=group_secret,json=groupSecret,proto3" json:"group_secret,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GroupIdentity) ProtoMessage() {}

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

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

func (x *GroupIdentity) GetGroupName() string {
	if x != nil {
		return x.GroupName
	}
	return ""
}

func (x *GroupIdentity) GetGroupSecret() string {
	if x != nil {
		return x.GroupSecret
	}
	return ""
}

type AclV1 struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Chains        []*Chain               `protobuf:"bytes,1,rep,name=chains,proto3" json:"chains,omitempty"`
	Group         *GroupInfo             `protobuf:"bytes,2,opt,name=group,proto3" json:"group,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AclV1) ProtoMessage() {}

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

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

func (x *AclV1) GetChains() []*Chain {
	if x != nil {
		return x.Chains
	}
	return nil
}

func (x *AclV1) GetGroup() *GroupInfo {
	if x != nil {
		return x.Group
	}
	return nil
}

// Connection tracking entry for stateful ACLs
type ConnTrackEntry struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	SrcAddr       *common.SocketAddr     `protobuf:"bytes,1,opt,name=src_addr,json=srcAddr,proto3" json:"src_addr,omitempty"`
	DstAddr       *common.SocketAddr     `protobuf:"bytes,2,opt,name=dst_addr,json=dstAddr,proto3" json:"dst_addr,omitempty"`
	Protocol      Protocol               `protobuf:"varint,3,opt,name=protocol,proto3,enum=acl.Protocol" json:"protocol,omitempty"` // IP protocol number (e.g., 6 = TCP, 17 = UDP)
	State         ConnState              `protobuf:"varint,4,opt,name=state,proto3,enum=acl.ConnState" json:"state,omitempty"`
	CreatedAt     uint64                 `protobuf:"varint,5,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` // Unix timestamp (seconds)
	LastSeen      uint64                 `protobuf:"varint,6,opt,name=last_seen,json=lastSeen,proto3" json:"last_seen,omitempty"`    // Unix timestamp (seconds)
	PacketCount   uint64                 `protobuf:"varint,7,opt,name=packet_count,json=packetCount,proto3" json:"packet_count,omitempty"`
	ByteCount     uint64                 `protobuf:"varint,8,opt,name=byte_count,json=byteCount,proto3" json:"byte_count,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ConnTrackEntry) ProtoMessage() {}

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

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

func (x *ConnTrackEntry) GetSrcAddr() *common.SocketAddr {
	if x != nil {
		return x.SrcAddr
	}
	return nil
}

func (x *ConnTrackEntry) GetDstAddr() *common.SocketAddr {
	if x != nil {
		return x.DstAddr
	}
	return nil
}

func (x *ConnTrackEntry) GetProtocol() Protocol {
	if x != nil {
		return x.Protocol
	}
	return Protocol_Unspecified
}

func (x *ConnTrackEntry) GetState() ConnState {
	if x != nil {
		return x.State
	}
	return ConnState_New
}

func (x *ConnTrackEntry) GetCreatedAt() uint64 {
	if x != nil {
		return x.CreatedAt
	}
	return 0
}

func (x *ConnTrackEntry) GetLastSeen() uint64 {
	if x != nil {
		return x.LastSeen
	}
	return 0
}

func (x *ConnTrackEntry) GetPacketCount() uint64 {
	if x != nil {
		return x.PacketCount
	}
	return 0
}

func (x *ConnTrackEntry) GetByteCount() uint64 {
	if x != nil {
		return x.ByteCount
	}
	return 0
}

// Top-level ACL configuration
type Acl struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	AclV1         *AclV1                 `protobuf:"bytes,2,opt,name=acl_v1,json=aclV1,proto3" json:"acl_v1,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Acl) ProtoMessage() {}

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

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

func (x *Acl) GetAclV1() *AclV1 {
	if x != nil {
		return x.AclV1
	}
	return nil
}

type StatItem struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	PacketCount   uint64                 `protobuf:"varint,1,opt,name=packet_count,json=packetCount,proto3" json:"packet_count,omitempty"`
	ByteCount     uint64                 `protobuf:"varint,2,opt,name=byte_count,json=byteCount,proto3" json:"byte_count,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*StatItem) ProtoMessage() {}

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

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

func (x *StatItem) GetPacketCount() uint64 {
	if x != nil {
		return x.PacketCount
	}
	return 0
}

func (x *StatItem) GetByteCount() uint64 {
	if x != nil {
		return x.ByteCount
	}
	return 0
}

type RuleStats struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Rule          *Rule                  `protobuf:"bytes,1,opt,name=rule,proto3" json:"rule,omitempty"`
	Stat          *StatItem              `protobuf:"bytes,2,opt,name=stat,proto3" json:"stat,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RuleStats) ProtoMessage() {}

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

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

func (x *RuleStats) GetRule() *Rule {
	if x != nil {
		return x.Rule
	}
	return nil
}

func (x *RuleStats) GetStat() *StatItem {
	if x != nil {
		return x.Stat
	}
	return nil
}

type AclStats struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Rules         []*RuleStats           `protobuf:"bytes,1,rep,name=rules,proto3" json:"rules,omitempty"`
	ConnTrack     []*ConnTrackEntry      `protobuf:"bytes,2,rep,name=conn_track,json=connTrack,proto3" json:"conn_track,omitempty"`
	Global        map[string]uint64      `protobuf:"bytes,3,rep,name=global,proto3" json:"global,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AclStats) ProtoMessage() {}

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

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

func (x *AclStats) GetRules() []*RuleStats {
	if x != nil {
		return x.Rules
	}
	return nil
}

func (x *AclStats) GetConnTrack() []*ConnTrackEntry {
	if x != nil {
		return x.ConnTrack
	}
	return nil
}

func (x *AclStats) GetGlobal() map[string]uint64 {
	if x != nil {
		return x.Global
	}
	return nil
}

var File_acl_proto protoreflect.FileDescriptor

const file_acl_proto_rawDesc = "" +
	"\n" +
	"\tacl.proto\x12\x03acl\x1a\fcommon.proto\"\x91\x01\n" +
	"\n" +
	"TimeWindow\x12 \n" +
	"\fdays_of_week\x18\x01 \x03(\rR\n" +
	"daysOfWeek\x12\x1d\n" +
	"\n" +
	"start_time\x18\x02 \x01(\rR\tstartTime\x12\x19\n" +
	"\bend_time\x18\x03 \x01(\rR\aendTime\x12'\n" +
	"\x0ftimezone_offset\x18\x04 \x01(\x05R\x0etimezoneOffset\"\xf3\x03\n" +
	"\x04Rule\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12 \n" +
	"\vdescription\x18\x02 \x01(\tR\vdescription\x12\x1a\n" +
	"\bpriority\x18\x03 \x01(\rR\bpriority\x12\x18\n" +
	"\aenabled\x18\x04 \x01(\bR\aenabled\x12)\n" +
	"\bprotocol\x18\x05 \x01(\x0e2\r.acl.ProtocolR\bprotocol\x12\x14\n" +
	"\x05ports\x18\x06 \x03(\tR\x05ports\x12\x1d\n" +
	"\n" +
	"source_ips\x18\a \x03(\tR\tsourceIps\x12'\n" +
	"\x0fdestination_ips\x18\b \x03(\tR\x0edestinationIps\x12!\n" +
	"\fsource_ports\x18\t \x03(\tR\vsourcePorts\x12#\n" +
	"\x06action\x18\n" +
	" \x01(\x0e2\v.acl.ActionR\x06action\x12\x1d\n" +
	"\n" +
	"rate_limit\x18\v \x01(\rR\trateLimit\x12\x1f\n" +
	"\vburst_limit\x18\f \x01(\rR\n" +
	"burstLimit\x12\x1a\n" +
	"\bstateful\x18\r \x01(\bR\bstateful\x12#\n" +
	"\rsource_groups\x18\x0e \x03(\tR\fsourceGroups\x12-\n" +
	"\x12destination_groups\x18\x0f \x03(\tR\x11destinationGroups\"\xdb\x01\n" +
	"\x05Chain\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12-\n" +
	"\n" +
	"chain_type\x18\x02 \x01(\x0e2\x0e.acl.ChainTypeR\tchainType\x12 \n" +
	"\vdescription\x18\x03 \x01(\tR\vdescription\x12\x18\n" +
	"\aenabled\x18\x04 \x01(\bR\aenabled\x12\x1f\n" +
	"\x05rules\x18\x05 \x03(\v2\t.acl.RuleR\x05rules\x122\n" +
	"\x0edefault_action\x18\x06 \x01(\x0e2\v.acl.ActionR\rdefaultAction\"U\n" +
	"\tGroupInfo\x12.\n" +
	"\bdeclares\x18\x01 \x03(\v2\x12.acl.GroupIdentityR\bdeclares\x12\x18\n" +
	"\amembers\x18\x02 \x03(\tR\amembers\"Q\n" +
	"\rGroupIdentity\x12\x1d\n" +
	"\n" +
	"group_name\x18\x01 \x01(\tR\tgroupName\x12!\n" +
	"\fgroup_secret\x18\x02 \x01(\tR\vgroupSecret\"Q\n" +
	"\x05AclV1\x12\"\n" +
	"\x06chains\x18\x01 \x03(\v2\n" +
	".acl.ChainR\x06chains\x12$\n" +
	"\x05group\x18\x02 \x01(\v2\x0e.acl.GroupInfoR\x05group\"\xbd\x02\n" +
	"\x0eConnTrackEntry\x12-\n" +
	"\bsrc_addr\x18\x01 \x01(\v2\x12.common.SocketAddrR\asrcAddr\x12-\n" +
	"\bdst_addr\x18\x02 \x01(\v2\x12.common.SocketAddrR\adstAddr\x12)\n" +
	"\bprotocol\x18\x03 \x01(\x0e2\r.acl.ProtocolR\bprotocol\x12$\n" +
	"\x05state\x18\x04 \x01(\x0e2\x0e.acl.ConnStateR\x05state\x12\x1d\n" +
	"\n" +
	"created_at\x18\x05 \x01(\x04R\tcreatedAt\x12\x1b\n" +
	"\tlast_seen\x18\x06 \x01(\x04R\blastSeen\x12!\n" +
	"\fpacket_count\x18\a \x01(\x04R\vpacketCount\x12\x1d\n" +
	"\n" +
	"byte_count\x18\b \x01(\x04R\tbyteCount\"(\n" +
	"\x03Acl\x12!\n" +
	"\x06acl_v1\x18\x02 \x01(\v2\n" +
	".acl.AclV1R\x05aclV1\"L\n" +
	"\bStatItem\x12!\n" +
	"\fpacket_count\x18\x01 \x01(\x04R\vpacketCount\x12\x1d\n" +
	"\n" +
	"byte_count\x18\x02 \x01(\x04R\tbyteCount\"M\n" +
	"\tRuleStats\x12\x1d\n" +
	"\x04rule\x18\x01 \x01(\v2\t.acl.RuleR\x04rule\x12!\n" +
	"\x04stat\x18\x02 \x01(\v2\r.acl.StatItemR\x04stat\"\xd2\x01\n" +
	"\bAclStats\x12$\n" +
	"\x05rules\x18\x01 \x03(\v2\x0e.acl.RuleStatsR\x05rules\x122\n" +
	"\n" +
	"conn_track\x18\x02 \x03(\v2\x13.acl.ConnTrackEntryR\tconnTrack\x121\n" +
	"\x06global\x18\x03 \x03(\v2\x19.acl.AclStats.GlobalEntryR\x06global\x1a9\n" +
	"\vGlobalEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x04R\x05value:\x028\x01*L\n" +
	"\bProtocol\x12\x0f\n" +
	"\vUnspecified\x10\x00\x12\a\n" +
	"\x03TCP\x10\x01\x12\a\n" +
	"\x03UDP\x10\x02\x12\b\n" +
	"\x04ICMP\x10\x03\x12\n" +
	"\n" +
	"\x06ICMPv6\x10\x04\x12\a\n" +
	"\x03Any\x10\x05*'\n" +
	"\x06Action\x12\b\n" +
	"\x04Noop\x10\x00\x12\t\n" +
	"\x05Allow\x10\x01\x12\b\n" +
	"\x04Drop\x10\x02*I\n" +
	"\tChainType\x12\x14\n" +
	"\x10UnspecifiedChain\x10\x00\x12\v\n" +
	"\aInbound\x10\x01\x12\f\n" +
	"\bOutbound\x10\x02\x12\v\n" +
	"\aForward\x10\x03*?\n" +
	"\tConnState\x12\a\n" +
	"\x03New\x10\x00\x12\x0f\n" +
	"\vEstablished\x10\x01\x12\v\n" +
	"\aRelated\x10\x02\x12\v\n" +
	"\aInvalid\x10\x03b\x06proto3"

var (
	file_acl_proto_rawDescOnce sync.Once
	file_acl_proto_rawDescData []byte
)

func file_acl_proto_rawDescGZIP() []byte {
	file_acl_proto_rawDescOnce.Do(func() {
		file_acl_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_acl_proto_rawDesc), len(file_acl_proto_rawDesc)))
	})
	return file_acl_proto_rawDescData
}

var file_acl_proto_enumTypes = make([]protoimpl.EnumInfo, 4)
var file_acl_proto_msgTypes = make([]protoimpl.MessageInfo, 12)
var file_acl_proto_goTypes = []any{
	(Protocol)(0),             // 0: acl.Protocol
	(Action)(0),               // 1: acl.Action
	(ChainType)(0),            // 2: acl.ChainType
	(ConnState)(0),            // 3: acl.ConnState
	(*TimeWindow)(nil),        // 4: acl.TimeWindow
	(*Rule)(nil),              // 5: acl.Rule
	(*Chain)(nil),             // 6: acl.Chain
	(*GroupInfo)(nil),         // 7: acl.GroupInfo
	(*GroupIdentity)(nil),     // 8: acl.GroupIdentity
	(*AclV1)(nil),             // 9: acl.AclV1
	(*ConnTrackEntry)(nil),    // 10: acl.ConnTrackEntry
	(*Acl)(nil),               // 11: acl.Acl
	(*StatItem)(nil),          // 12: acl.StatItem
	(*RuleStats)(nil),         // 13: acl.RuleStats
	(*AclStats)(nil),          // 14: acl.AclStats
	nil,                       // 15: acl.AclStats.GlobalEntry
	(*common.SocketAddr)(nil), // 16: common.SocketAddr
}
var file_acl_proto_depIdxs = []int32{
	0,  // 0: acl.Rule.protocol:type_name -> acl.Protocol
	1,  // 1: acl.Rule.action:type_name -> acl.Action
	2,  // 2: acl.Chain.chain_type:type_name -> acl.ChainType
	5,  // 3: acl.Chain.rules:type_name -> acl.Rule
	1,  // 4: acl.Chain.default_action:type_name -> acl.Action
	8,  // 5: acl.GroupInfo.declares:type_name -> acl.GroupIdentity
	6,  // 6: acl.AclV1.chains:type_name -> acl.Chain
	7,  // 7: acl.AclV1.group:type_name -> acl.GroupInfo
	16, // 8: acl.ConnTrackEntry.src_addr:type_name -> common.SocketAddr
	16, // 9: acl.ConnTrackEntry.dst_addr:type_name -> common.SocketAddr
	0,  // 10: acl.ConnTrackEntry.protocol:type_name -> acl.Protocol
	3,  // 11: acl.ConnTrackEntry.state:type_name -> acl.ConnState
	9,  // 12: acl.Acl.acl_v1:type_name -> acl.AclV1
	5,  // 13: acl.RuleStats.rule:type_name -> acl.Rule
	12, // 14: acl.RuleStats.stat:type_name -> acl.StatItem
	13, // 15: acl.AclStats.rules:type_name -> acl.RuleStats
	10, // 16: acl.AclStats.conn_track:type_name -> acl.ConnTrackEntry
	15, // 17: acl.AclStats.global:type_name -> acl.AclStats.GlobalEntry
	18, // [18:18] is the sub-list for method output_type
	18, // [18:18] is the sub-list for method input_type
	18, // [18:18] is the sub-list for extension type_name
	18, // [18:18] is the sub-list for extension extendee
	0,  // [0:18] is the sub-list for field type_name
}

func init() { file_acl_proto_init() }
func file_acl_proto_init() {
	if File_acl_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_acl_proto_rawDesc), len(file_acl_proto_rawDesc)),
			NumEnums:      4,
			NumMessages:   12,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_acl_proto_goTypes,
		DependencyIndexes: file_acl_proto_depIdxs,
		EnumInfos:         file_acl_proto_enumTypes,
		MessageInfos:      file_acl_proto_msgTypes,
	}.Build()
	File_acl_proto = out.File
	file_acl_proto_goTypes = nil
	file_acl_proto_depIdxs = nil
}