// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.8
// 	protoc        v6.32.0
// source: filecache.proto

package filecachepb

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

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

type FileCache struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	SyncTime      *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=sync_time,json=syncTime,proto3" json:"sync_time,omitempty"`
	Profiles      []*Profile             `protobuf:"bytes,2,rep,name=profiles,proto3" json:"profiles,omitempty"`
	Devices       []*Device              `protobuf:"bytes,3,rep,name=devices,proto3" json:"devices,omitempty"`
	Version       int32                  `protobuf:"varint,4,opt,name=version,proto3" json:"version,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FileCache) ProtoMessage() {}

func (x *FileCache) ProtoReflect() protoreflect.Message {
	mi := &file_filecache_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 FileCache.ProtoReflect.Descriptor instead.
func (*FileCache) Descriptor() ([]byte, []int) {
	return file_filecache_proto_rawDescGZIP(), []int{0}
}

func (x *FileCache) GetSyncTime() *timestamppb.Timestamp {
	if x != nil {
		return x.SyncTime
	}
	return nil
}

func (x *FileCache) GetProfiles() []*Profile {
	if x != nil {
		return x.Profiles
	}
	return nil
}

func (x *FileCache) GetDevices() []*Device {
	if x != nil {
		return x.Devices
	}
	return nil
}

func (x *FileCache) GetVersion() int32 {
	if x != nil {
		return x.Version
	}
	return 0
}

type Profile struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	CustomDomains *AccountCustomDomains  `protobuf:"bytes,20,opt,name=custom_domains,json=customDomains,proto3" json:"custom_domains,omitempty"`
	FilterConfig  *FilterConfig          `protobuf:"bytes,1,opt,name=filter_config,json=filterConfig,proto3" json:"filter_config,omitempty"`
	Access        *Access                `protobuf:"bytes,2,opt,name=access,proto3" json:"access,omitempty"`
	// Types that are valid to be assigned to BlockingMode:
	//
	//	*Profile_BlockingModeCustomIp
	//	*Profile_BlockingModeNxdomain
	//	*Profile_BlockingModeNullIp
	//	*Profile_BlockingModeRefused
	BlockingMode        isProfile_BlockingMode `protobuf_oneof:"blocking_mode"`
	Ratelimiter         *Ratelimiter           `protobuf:"bytes,7,opt,name=ratelimiter,proto3" json:"ratelimiter,omitempty"`
	AccountId           string                 `protobuf:"bytes,19,opt,name=account_id,json=accountId,proto3" json:"account_id,omitempty"`
	ProfileId           string                 `protobuf:"bytes,8,opt,name=profile_id,json=profileId,proto3" json:"profile_id,omitempty"`
	DeviceIds           []string               `protobuf:"bytes,9,rep,name=device_ids,json=deviceIds,proto3" json:"device_ids,omitempty"`
	FilteredResponseTtl *durationpb.Duration   `protobuf:"bytes,10,opt,name=filtered_response_ttl,json=filteredResponseTtl,proto3" json:"filtered_response_ttl,omitempty"`
	AutoDevicesEnabled  bool                   `protobuf:"varint,11,opt,name=auto_devices_enabled,json=autoDevicesEnabled,proto3" json:"auto_devices_enabled,omitempty"`
	BlockChromePrefetch bool                   `protobuf:"varint,12,opt,name=block_chrome_prefetch,json=blockChromePrefetch,proto3" json:"block_chrome_prefetch,omitempty"`
	BlockFirefoxCanary  bool                   `protobuf:"varint,13,opt,name=block_firefox_canary,json=blockFirefoxCanary,proto3" json:"block_firefox_canary,omitempty"`
	BlockPrivateRelay   bool                   `protobuf:"varint,14,opt,name=block_private_relay,json=blockPrivateRelay,proto3" json:"block_private_relay,omitempty"`
	Deleted             bool                   `protobuf:"varint,15,opt,name=deleted,proto3" json:"deleted,omitempty"`
	FilteringEnabled    bool                   `protobuf:"varint,16,opt,name=filtering_enabled,json=filteringEnabled,proto3" json:"filtering_enabled,omitempty"`
	IpLogEnabled        bool                   `protobuf:"varint,17,opt,name=ip_log_enabled,json=ipLogEnabled,proto3" json:"ip_log_enabled,omitempty"`
	QueryLogEnabled     bool                   `protobuf:"varint,18,opt,name=query_log_enabled,json=queryLogEnabled,proto3" json:"query_log_enabled,omitempty"`
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

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

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

func (*Profile) ProtoMessage() {}

func (x *Profile) ProtoReflect() protoreflect.Message {
	mi := &file_filecache_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 Profile.ProtoReflect.Descriptor instead.
func (*Profile) Descriptor() ([]byte, []int) {
	return file_filecache_proto_rawDescGZIP(), []int{1}
}

func (x *Profile) GetCustomDomains() *AccountCustomDomains {
	if x != nil {
		return x.CustomDomains
	}
	return nil
}

func (x *Profile) GetFilterConfig() *FilterConfig {
	if x != nil {
		return x.FilterConfig
	}
	return nil
}

func (x *Profile) GetAccess() *Access {
	if x != nil {
		return x.Access
	}
	return nil
}

func (x *Profile) GetBlockingMode() isProfile_BlockingMode {
	if x != nil {
		return x.BlockingMode
	}
	return nil
}

func (x *Profile) GetBlockingModeCustomIp() *BlockingModeCustomIP {
	if x != nil {
		if x, ok := x.BlockingMode.(*Profile_BlockingModeCustomIp); ok {
			return x.BlockingModeCustomIp
		}
	}
	return nil
}

func (x *Profile) GetBlockingModeNxdomain() *BlockingModeNXDOMAIN {
	if x != nil {
		if x, ok := x.BlockingMode.(*Profile_BlockingModeNxdomain); ok {
			return x.BlockingModeNxdomain
		}
	}
	return nil
}

func (x *Profile) GetBlockingModeNullIp() *BlockingModeNullIP {
	if x != nil {
		if x, ok := x.BlockingMode.(*Profile_BlockingModeNullIp); ok {
			return x.BlockingModeNullIp
		}
	}
	return nil
}

func (x *Profile) GetBlockingModeRefused() *BlockingModeREFUSED {
	if x != nil {
		if x, ok := x.BlockingMode.(*Profile_BlockingModeRefused); ok {
			return x.BlockingModeRefused
		}
	}
	return nil
}

func (x *Profile) GetRatelimiter() *Ratelimiter {
	if x != nil {
		return x.Ratelimiter
	}
	return nil
}

func (x *Profile) GetAccountId() string {
	if x != nil {
		return x.AccountId
	}
	return ""
}

func (x *Profile) GetProfileId() string {
	if x != nil {
		return x.ProfileId
	}
	return ""
}

func (x *Profile) GetDeviceIds() []string {
	if x != nil {
		return x.DeviceIds
	}
	return nil
}

func (x *Profile) GetFilteredResponseTtl() *durationpb.Duration {
	if x != nil {
		return x.FilteredResponseTtl
	}
	return nil
}

func (x *Profile) GetAutoDevicesEnabled() bool {
	if x != nil {
		return x.AutoDevicesEnabled
	}
	return false
}

func (x *Profile) GetBlockChromePrefetch() bool {
	if x != nil {
		return x.BlockChromePrefetch
	}
	return false
}

func (x *Profile) GetBlockFirefoxCanary() bool {
	if x != nil {
		return x.BlockFirefoxCanary
	}
	return false
}

func (x *Profile) GetBlockPrivateRelay() bool {
	if x != nil {
		return x.BlockPrivateRelay
	}
	return false
}

func (x *Profile) GetDeleted() bool {
	if x != nil {
		return x.Deleted
	}
	return false
}

func (x *Profile) GetFilteringEnabled() bool {
	if x != nil {
		return x.FilteringEnabled
	}
	return false
}

func (x *Profile) GetIpLogEnabled() bool {
	if x != nil {
		return x.IpLogEnabled
	}
	return false
}

func (x *Profile) GetQueryLogEnabled() bool {
	if x != nil {
		return x.QueryLogEnabled
	}
	return false
}

type isProfile_BlockingMode interface {
	isProfile_BlockingMode()
}

type Profile_BlockingModeCustomIp struct {
	BlockingModeCustomIp *BlockingModeCustomIP `protobuf:"bytes,3,opt,name=blocking_mode_custom_ip,json=blockingModeCustomIp,proto3,oneof"`
}

type Profile_BlockingModeNxdomain struct {
	BlockingModeNxdomain *BlockingModeNXDOMAIN `protobuf:"bytes,4,opt,name=blocking_mode_nxdomain,json=blockingModeNxdomain,proto3,oneof"`
}

type Profile_BlockingModeNullIp struct {
	BlockingModeNullIp *BlockingModeNullIP `protobuf:"bytes,5,opt,name=blocking_mode_null_ip,json=blockingModeNullIp,proto3,oneof"`
}

type Profile_BlockingModeRefused struct {
	BlockingModeRefused *BlockingModeREFUSED `protobuf:"bytes,6,opt,name=blocking_mode_refused,json=blockingModeRefused,proto3,oneof"`
}

func (*Profile_BlockingModeCustomIp) isProfile_BlockingMode() {}

func (*Profile_BlockingModeNxdomain) isProfile_BlockingMode() {}

func (*Profile_BlockingModeNullIp) isProfile_BlockingMode() {}

func (*Profile_BlockingModeRefused) isProfile_BlockingMode() {}

type AccountCustomDomains struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Domains       []*CustomDomainConfig  `protobuf:"bytes,1,rep,name=domains,proto3" json:"domains,omitempty"`
	Enabled       bool                   `protobuf:"varint,2,opt,name=enabled,proto3" json:"enabled,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AccountCustomDomains) ProtoMessage() {}

func (x *AccountCustomDomains) ProtoReflect() protoreflect.Message {
	mi := &file_filecache_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 AccountCustomDomains.ProtoReflect.Descriptor instead.
func (*AccountCustomDomains) Descriptor() ([]byte, []int) {
	return file_filecache_proto_rawDescGZIP(), []int{2}
}

func (x *AccountCustomDomains) GetDomains() []*CustomDomainConfig {
	if x != nil {
		return x.Domains
	}
	return nil
}

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

type CustomDomainConfig struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to State:
	//
	//	*CustomDomainConfig_StateCurrent_
	//	*CustomDomainConfig_StatePending_
	State         isCustomDomainConfig_State `protobuf_oneof:"state"`
	Domains       []string                   `protobuf:"bytes,3,rep,name=domains,proto3" json:"domains,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CustomDomainConfig) ProtoMessage() {}

func (x *CustomDomainConfig) ProtoReflect() protoreflect.Message {
	mi := &file_filecache_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 CustomDomainConfig.ProtoReflect.Descriptor instead.
func (*CustomDomainConfig) Descriptor() ([]byte, []int) {
	return file_filecache_proto_rawDescGZIP(), []int{3}
}

func (x *CustomDomainConfig) GetState() isCustomDomainConfig_State {
	if x != nil {
		return x.State
	}
	return nil
}

func (x *CustomDomainConfig) GetStateCurrent() *CustomDomainConfig_StateCurrent {
	if x != nil {
		if x, ok := x.State.(*CustomDomainConfig_StateCurrent_); ok {
			return x.StateCurrent
		}
	}
	return nil
}

func (x *CustomDomainConfig) GetStatePending() *CustomDomainConfig_StatePending {
	if x != nil {
		if x, ok := x.State.(*CustomDomainConfig_StatePending_); ok {
			return x.StatePending
		}
	}
	return nil
}

func (x *CustomDomainConfig) GetDomains() []string {
	if x != nil {
		return x.Domains
	}
	return nil
}

type isCustomDomainConfig_State interface {
	isCustomDomainConfig_State()
}

type CustomDomainConfig_StateCurrent_ struct {
	StateCurrent *CustomDomainConfig_StateCurrent `protobuf:"bytes,1,opt,name=state_current,json=stateCurrent,proto3,oneof"`
}

type CustomDomainConfig_StatePending_ struct {
	StatePending *CustomDomainConfig_StatePending `protobuf:"bytes,2,opt,name=state_pending,json=statePending,proto3,oneof"`
}

func (*CustomDomainConfig_StateCurrent_) isCustomDomainConfig_State() {}

func (*CustomDomainConfig_StatePending_) isCustomDomainConfig_State() {}

type FilterConfig struct {
	state         protoimpl.MessageState     `protogen:"open.v1"`
	Custom        *FilterConfig_Custom       `protobuf:"bytes,1,opt,name=custom,proto3" json:"custom,omitempty"`
	Parental      *FilterConfig_Parental     `protobuf:"bytes,2,opt,name=parental,proto3" json:"parental,omitempty"`
	RuleList      *FilterConfig_RuleList     `protobuf:"bytes,3,opt,name=rule_list,json=ruleList,proto3" json:"rule_list,omitempty"`
	SafeBrowsing  *FilterConfig_SafeBrowsing `protobuf:"bytes,4,opt,name=safe_browsing,json=safeBrowsing,proto3" json:"safe_browsing,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FilterConfig) ProtoMessage() {}

func (x *FilterConfig) ProtoReflect() protoreflect.Message {
	mi := &file_filecache_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 FilterConfig.ProtoReflect.Descriptor instead.
func (*FilterConfig) Descriptor() ([]byte, []int) {
	return file_filecache_proto_rawDescGZIP(), []int{4}
}

func (x *FilterConfig) GetCustom() *FilterConfig_Custom {
	if x != nil {
		return x.Custom
	}
	return nil
}

func (x *FilterConfig) GetParental() *FilterConfig_Parental {
	if x != nil {
		return x.Parental
	}
	return nil
}

func (x *FilterConfig) GetRuleList() *FilterConfig_RuleList {
	if x != nil {
		return x.RuleList
	}
	return nil
}

func (x *FilterConfig) GetSafeBrowsing() *FilterConfig_SafeBrowsing {
	if x != nil {
		return x.SafeBrowsing
	}
	return nil
}

type DayInterval struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Start         uint32                 `protobuf:"varint,1,opt,name=start,proto3" json:"start,omitempty"`
	End           uint32                 `protobuf:"varint,2,opt,name=end,proto3" json:"end,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DayInterval) ProtoMessage() {}

func (x *DayInterval) ProtoReflect() protoreflect.Message {
	mi := &file_filecache_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 DayInterval.ProtoReflect.Descriptor instead.
func (*DayInterval) Descriptor() ([]byte, []int) {
	return file_filecache_proto_rawDescGZIP(), []int{5}
}

func (x *DayInterval) GetStart() uint32 {
	if x != nil {
		return x.Start
	}
	return 0
}

func (x *DayInterval) GetEnd() uint32 {
	if x != nil {
		return x.End
	}
	return 0
}

type BlockingModeCustomIP struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Ipv4          [][]byte               `protobuf:"bytes,1,rep,name=ipv4,proto3" json:"ipv4,omitempty"`
	Ipv6          [][]byte               `protobuf:"bytes,2,rep,name=ipv6,proto3" json:"ipv6,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*BlockingModeCustomIP) ProtoMessage() {}

func (x *BlockingModeCustomIP) ProtoReflect() protoreflect.Message {
	mi := &file_filecache_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 BlockingModeCustomIP.ProtoReflect.Descriptor instead.
func (*BlockingModeCustomIP) Descriptor() ([]byte, []int) {
	return file_filecache_proto_rawDescGZIP(), []int{6}
}

func (x *BlockingModeCustomIP) GetIpv4() [][]byte {
	if x != nil {
		return x.Ipv4
	}
	return nil
}

func (x *BlockingModeCustomIP) GetIpv6() [][]byte {
	if x != nil {
		return x.Ipv6
	}
	return nil
}

type BlockingModeNXDOMAIN struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*BlockingModeNXDOMAIN) ProtoMessage() {}

func (x *BlockingModeNXDOMAIN) ProtoReflect() protoreflect.Message {
	mi := &file_filecache_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 BlockingModeNXDOMAIN.ProtoReflect.Descriptor instead.
func (*BlockingModeNXDOMAIN) Descriptor() ([]byte, []int) {
	return file_filecache_proto_rawDescGZIP(), []int{7}
}

type BlockingModeNullIP struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*BlockingModeNullIP) ProtoMessage() {}

func (x *BlockingModeNullIP) ProtoReflect() protoreflect.Message {
	mi := &file_filecache_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 BlockingModeNullIP.ProtoReflect.Descriptor instead.
func (*BlockingModeNullIP) Descriptor() ([]byte, []int) {
	return file_filecache_proto_rawDescGZIP(), []int{8}
}

type BlockingModeREFUSED struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*BlockingModeREFUSED) ProtoMessage() {}

func (x *BlockingModeREFUSED) ProtoReflect() protoreflect.Message {
	mi := &file_filecache_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 BlockingModeREFUSED.ProtoReflect.Descriptor instead.
func (*BlockingModeREFUSED) Descriptor() ([]byte, []int) {
	return file_filecache_proto_rawDescGZIP(), []int{9}
}

type Device struct {
	state            protoimpl.MessageState  `protogen:"open.v1"`
	Authentication   *AuthenticationSettings `protobuf:"bytes,6,opt,name=authentication,proto3" json:"authentication,omitempty"`
	DeviceId         string                  `protobuf:"bytes,1,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
	DeviceName       string                  `protobuf:"bytes,3,opt,name=device_name,json=deviceName,proto3" json:"device_name,omitempty"`
	HumanIdLower     string                  `protobuf:"bytes,7,opt,name=human_id_lower,json=humanIdLower,proto3" json:"human_id_lower,omitempty"`
	LinkedIp         []byte                  `protobuf:"bytes,2,opt,name=linked_ip,json=linkedIp,proto3" json:"linked_ip,omitempty"`
	DedicatedIps     [][]byte                `protobuf:"bytes,4,rep,name=dedicated_ips,json=dedicatedIps,proto3" json:"dedicated_ips,omitempty"`
	FilteringEnabled bool                    `protobuf:"varint,5,opt,name=filtering_enabled,json=filteringEnabled,proto3" json:"filtering_enabled,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

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

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

func (*Device) ProtoMessage() {}

func (x *Device) ProtoReflect() protoreflect.Message {
	mi := &file_filecache_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 Device.ProtoReflect.Descriptor instead.
func (*Device) Descriptor() ([]byte, []int) {
	return file_filecache_proto_rawDescGZIP(), []int{10}
}

func (x *Device) GetAuthentication() *AuthenticationSettings {
	if x != nil {
		return x.Authentication
	}
	return nil
}

func (x *Device) GetDeviceId() string {
	if x != nil {
		return x.DeviceId
	}
	return ""
}

func (x *Device) GetDeviceName() string {
	if x != nil {
		return x.DeviceName
	}
	return ""
}

func (x *Device) GetHumanIdLower() string {
	if x != nil {
		return x.HumanIdLower
	}
	return ""
}

func (x *Device) GetLinkedIp() []byte {
	if x != nil {
		return x.LinkedIp
	}
	return nil
}

func (x *Device) GetDedicatedIps() [][]byte {
	if x != nil {
		return x.DedicatedIps
	}
	return nil
}

func (x *Device) GetFilteringEnabled() bool {
	if x != nil {
		return x.FilteringEnabled
	}
	return false
}

type Access struct {
	state                protoimpl.MessageState `protogen:"open.v1"`
	AllowlistAsn         []uint32               `protobuf:"varint,4,rep,packed,name=allowlist_asn,json=allowlistAsn,proto3" json:"allowlist_asn,omitempty"`
	AllowlistCidr        []*CidrRange           `protobuf:"bytes,1,rep,name=allowlist_cidr,json=allowlistCidr,proto3" json:"allowlist_cidr,omitempty"`
	BlocklistAsn         []uint32               `protobuf:"varint,5,rep,packed,name=blocklist_asn,json=blocklistAsn,proto3" json:"blocklist_asn,omitempty"`
	BlocklistCidr        []*CidrRange           `protobuf:"bytes,2,rep,name=blocklist_cidr,json=blocklistCidr,proto3" json:"blocklist_cidr,omitempty"`
	BlocklistDomainRules []string               `protobuf:"bytes,3,rep,name=blocklist_domain_rules,json=blocklistDomainRules,proto3" json:"blocklist_domain_rules,omitempty"`
	StandardEnabled      bool                   `protobuf:"varint,6,opt,name=standard_enabled,json=standardEnabled,proto3" json:"standard_enabled,omitempty"`
	unknownFields        protoimpl.UnknownFields
	sizeCache            protoimpl.SizeCache
}

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

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

func (*Access) ProtoMessage() {}

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

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

func (x *Access) GetAllowlistAsn() []uint32 {
	if x != nil {
		return x.AllowlistAsn
	}
	return nil
}

func (x *Access) GetAllowlistCidr() []*CidrRange {
	if x != nil {
		return x.AllowlistCidr
	}
	return nil
}

func (x *Access) GetBlocklistAsn() []uint32 {
	if x != nil {
		return x.BlocklistAsn
	}
	return nil
}

func (x *Access) GetBlocklistCidr() []*CidrRange {
	if x != nil {
		return x.BlocklistCidr
	}
	return nil
}

func (x *Access) GetBlocklistDomainRules() []string {
	if x != nil {
		return x.BlocklistDomainRules
	}
	return nil
}

func (x *Access) GetStandardEnabled() bool {
	if x != nil {
		return x.StandardEnabled
	}
	return false
}

type CidrRange struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Address       []byte                 `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	Prefix        uint32                 `protobuf:"varint,2,opt,name=prefix,proto3" json:"prefix,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CidrRange) ProtoMessage() {}

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

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

func (x *CidrRange) GetAddress() []byte {
	if x != nil {
		return x.Address
	}
	return nil
}

func (x *CidrRange) GetPrefix() uint32 {
	if x != nil {
		return x.Prefix
	}
	return 0
}

type AuthenticationSettings struct {
	state       protoimpl.MessageState `protogen:"open.v1"`
	DohAuthOnly bool                   `protobuf:"varint,1,opt,name=doh_auth_only,json=dohAuthOnly,proto3" json:"doh_auth_only,omitempty"`
	// Types that are valid to be assigned to DohPasswordHash:
	//
	//	*AuthenticationSettings_PasswordHashBcrypt
	DohPasswordHash isAuthenticationSettings_DohPasswordHash `protobuf_oneof:"doh_password_hash"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*AuthenticationSettings) ProtoMessage() {}

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

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

func (x *AuthenticationSettings) GetDohAuthOnly() bool {
	if x != nil {
		return x.DohAuthOnly
	}
	return false
}

func (x *AuthenticationSettings) GetDohPasswordHash() isAuthenticationSettings_DohPasswordHash {
	if x != nil {
		return x.DohPasswordHash
	}
	return nil
}

func (x *AuthenticationSettings) GetPasswordHashBcrypt() []byte {
	if x != nil {
		if x, ok := x.DohPasswordHash.(*AuthenticationSettings_PasswordHashBcrypt); ok {
			return x.PasswordHashBcrypt
		}
	}
	return nil
}

type isAuthenticationSettings_DohPasswordHash interface {
	isAuthenticationSettings_DohPasswordHash()
}

type AuthenticationSettings_PasswordHashBcrypt struct {
	PasswordHashBcrypt []byte `protobuf:"bytes,2,opt,name=password_hash_bcrypt,json=passwordHashBcrypt,proto3,oneof"`
}

func (*AuthenticationSettings_PasswordHashBcrypt) isAuthenticationSettings_DohPasswordHash() {}

type Ratelimiter struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ClientCidr    []*CidrRange           `protobuf:"bytes,1,rep,name=client_cidr,json=clientCidr,proto3" json:"client_cidr,omitempty"`
	Rps           uint32                 `protobuf:"varint,2,opt,name=rps,proto3" json:"rps,omitempty"`
	Enabled       bool                   `protobuf:"varint,3,opt,name=enabled,proto3" json:"enabled,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Ratelimiter) ProtoMessage() {}

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

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

func (x *Ratelimiter) GetClientCidr() []*CidrRange {
	if x != nil {
		return x.ClientCidr
	}
	return nil
}

func (x *Ratelimiter) GetRps() uint32 {
	if x != nil {
		return x.Rps
	}
	return 0
}

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

type CustomDomainConfig_StateCurrent struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	NotBefore     *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=not_before,json=notBefore,proto3" json:"not_before,omitempty"`
	NotAfter      *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=not_after,json=notAfter,proto3" json:"not_after,omitempty"`
	CertName      string                 `protobuf:"bytes,3,opt,name=cert_name,json=certName,proto3" json:"cert_name,omitempty"`
	Enabled       bool                   `protobuf:"varint,4,opt,name=enabled,proto3" json:"enabled,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CustomDomainConfig_StateCurrent) ProtoMessage() {}

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

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

func (x *CustomDomainConfig_StateCurrent) GetNotBefore() *timestamppb.Timestamp {
	if x != nil {
		return x.NotBefore
	}
	return nil
}

func (x *CustomDomainConfig_StateCurrent) GetNotAfter() *timestamppb.Timestamp {
	if x != nil {
		return x.NotAfter
	}
	return nil
}

func (x *CustomDomainConfig_StateCurrent) GetCertName() string {
	if x != nil {
		return x.CertName
	}
	return ""
}

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

type CustomDomainConfig_StatePending struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Expire        *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=expire,proto3" json:"expire,omitempty"`
	WellKnownPath string                 `protobuf:"bytes,2,opt,name=well_known_path,json=wellKnownPath,proto3" json:"well_known_path,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CustomDomainConfig_StatePending) ProtoMessage() {}

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

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

func (x *CustomDomainConfig_StatePending) GetExpire() *timestamppb.Timestamp {
	if x != nil {
		return x.Expire
	}
	return nil
}

func (x *CustomDomainConfig_StatePending) GetWellKnownPath() string {
	if x != nil {
		return x.WellKnownPath
	}
	return ""
}

type FilterConfig_Custom struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Rules         []string               `protobuf:"bytes,3,rep,name=rules,proto3" json:"rules,omitempty"`
	Enabled       bool                   `protobuf:"varint,4,opt,name=enabled,proto3" json:"enabled,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FilterConfig_Custom) ProtoMessage() {}

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

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

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

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

type FilterConfig_Parental struct {
	state                    protoimpl.MessageState `protogen:"open.v1"`
	PauseSchedule            *FilterConfig_Schedule `protobuf:"bytes,1,opt,name=pause_schedule,json=pauseSchedule,proto3" json:"pause_schedule,omitempty"`
	BlockedServices          []string               `protobuf:"bytes,2,rep,name=blocked_services,json=blockedServices,proto3" json:"blocked_services,omitempty"`
	Enabled                  bool                   `protobuf:"varint,3,opt,name=enabled,proto3" json:"enabled,omitempty"`
	AdultBlockingEnabled     bool                   `protobuf:"varint,4,opt,name=adult_blocking_enabled,json=adultBlockingEnabled,proto3" json:"adult_blocking_enabled,omitempty"`
	SafeSearchGeneralEnabled bool                   `protobuf:"varint,5,opt,name=safe_search_general_enabled,json=safeSearchGeneralEnabled,proto3" json:"safe_search_general_enabled,omitempty"`
	SafeSearchYoutubeEnabled bool                   `protobuf:"varint,6,opt,name=safe_search_youtube_enabled,json=safeSearchYoutubeEnabled,proto3" json:"safe_search_youtube_enabled,omitempty"`
	unknownFields            protoimpl.UnknownFields
	sizeCache                protoimpl.SizeCache
}

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

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

func (*FilterConfig_Parental) ProtoMessage() {}

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

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

func (x *FilterConfig_Parental) GetPauseSchedule() *FilterConfig_Schedule {
	if x != nil {
		return x.PauseSchedule
	}
	return nil
}

func (x *FilterConfig_Parental) GetBlockedServices() []string {
	if x != nil {
		return x.BlockedServices
	}
	return nil
}

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

func (x *FilterConfig_Parental) GetAdultBlockingEnabled() bool {
	if x != nil {
		return x.AdultBlockingEnabled
	}
	return false
}

func (x *FilterConfig_Parental) GetSafeSearchGeneralEnabled() bool {
	if x != nil {
		return x.SafeSearchGeneralEnabled
	}
	return false
}

func (x *FilterConfig_Parental) GetSafeSearchYoutubeEnabled() bool {
	if x != nil {
		return x.SafeSearchYoutubeEnabled
	}
	return false
}

type FilterConfig_Schedule struct {
	state         protoimpl.MessageState       `protogen:"open.v1"`
	Week          *FilterConfig_WeeklySchedule `protobuf:"bytes,1,opt,name=week,proto3" json:"week,omitempty"`
	TimeZone      string                       `protobuf:"bytes,2,opt,name=time_zone,json=timeZone,proto3" json:"time_zone,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FilterConfig_Schedule) ProtoMessage() {}

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

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

func (x *FilterConfig_Schedule) GetWeek() *FilterConfig_WeeklySchedule {
	if x != nil {
		return x.Week
	}
	return nil
}

func (x *FilterConfig_Schedule) GetTimeZone() string {
	if x != nil {
		return x.TimeZone
	}
	return ""
}

type FilterConfig_WeeklySchedule struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Mon           *DayInterval           `protobuf:"bytes,1,opt,name=mon,proto3" json:"mon,omitempty"`
	Tue           *DayInterval           `protobuf:"bytes,2,opt,name=tue,proto3" json:"tue,omitempty"`
	Wed           *DayInterval           `protobuf:"bytes,3,opt,name=wed,proto3" json:"wed,omitempty"`
	Thu           *DayInterval           `protobuf:"bytes,4,opt,name=thu,proto3" json:"thu,omitempty"`
	Fri           *DayInterval           `protobuf:"bytes,5,opt,name=fri,proto3" json:"fri,omitempty"`
	Sat           *DayInterval           `protobuf:"bytes,6,opt,name=sat,proto3" json:"sat,omitempty"`
	Sun           *DayInterval           `protobuf:"bytes,7,opt,name=sun,proto3" json:"sun,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FilterConfig_WeeklySchedule) ProtoMessage() {}

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

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

func (x *FilterConfig_WeeklySchedule) GetMon() *DayInterval {
	if x != nil {
		return x.Mon
	}
	return nil
}

func (x *FilterConfig_WeeklySchedule) GetTue() *DayInterval {
	if x != nil {
		return x.Tue
	}
	return nil
}

func (x *FilterConfig_WeeklySchedule) GetWed() *DayInterval {
	if x != nil {
		return x.Wed
	}
	return nil
}

func (x *FilterConfig_WeeklySchedule) GetThu() *DayInterval {
	if x != nil {
		return x.Thu
	}
	return nil
}

func (x *FilterConfig_WeeklySchedule) GetFri() *DayInterval {
	if x != nil {
		return x.Fri
	}
	return nil
}

func (x *FilterConfig_WeeklySchedule) GetSat() *DayInterval {
	if x != nil {
		return x.Sat
	}
	return nil
}

func (x *FilterConfig_WeeklySchedule) GetSun() *DayInterval {
	if x != nil {
		return x.Sun
	}
	return nil
}

type FilterConfig_RuleList struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Ids           []string               `protobuf:"bytes,1,rep,name=ids,proto3" json:"ids,omitempty"`
	Enabled       bool                   `protobuf:"varint,2,opt,name=enabled,proto3" json:"enabled,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *FilterConfig_RuleList) Reset() {
	*x = FilterConfig_RuleList{}
	mi := &file_filecache_proto_msgTypes[21]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*FilterConfig_RuleList) ProtoMessage() {}

func (x *FilterConfig_RuleList) ProtoReflect() protoreflect.Message {
	mi := &file_filecache_proto_msgTypes[21]
	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 FilterConfig_RuleList.ProtoReflect.Descriptor instead.
func (*FilterConfig_RuleList) Descriptor() ([]byte, []int) {
	return file_filecache_proto_rawDescGZIP(), []int{4, 4}
}

func (x *FilterConfig_RuleList) GetIds() []string {
	if x != nil {
		return x.Ids
	}
	return nil
}

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

type FilterConfig_SafeBrowsing struct {
	state                         protoimpl.MessageState `protogen:"open.v1"`
	Enabled                       bool                   `protobuf:"varint,1,opt,name=enabled,proto3" json:"enabled,omitempty"`
	DangerousDomainsEnabled       bool                   `protobuf:"varint,2,opt,name=dangerous_domains_enabled,json=dangerousDomainsEnabled,proto3" json:"dangerous_domains_enabled,omitempty"`
	NewlyRegisteredDomainsEnabled bool                   `protobuf:"varint,3,opt,name=newly_registered_domains_enabled,json=newlyRegisteredDomainsEnabled,proto3" json:"newly_registered_domains_enabled,omitempty"`
	unknownFields                 protoimpl.UnknownFields
	sizeCache                     protoimpl.SizeCache
}

func (x *FilterConfig_SafeBrowsing) Reset() {
	*x = FilterConfig_SafeBrowsing{}
	mi := &file_filecache_proto_msgTypes[22]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*FilterConfig_SafeBrowsing) ProtoMessage() {}

func (x *FilterConfig_SafeBrowsing) ProtoReflect() protoreflect.Message {
	mi := &file_filecache_proto_msgTypes[22]
	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 FilterConfig_SafeBrowsing.ProtoReflect.Descriptor instead.
func (*FilterConfig_SafeBrowsing) Descriptor() ([]byte, []int) {
	return file_filecache_proto_rawDescGZIP(), []int{4, 5}
}

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

func (x *FilterConfig_SafeBrowsing) GetDangerousDomainsEnabled() bool {
	if x != nil {
		return x.DangerousDomainsEnabled
	}
	return false
}

func (x *FilterConfig_SafeBrowsing) GetNewlyRegisteredDomainsEnabled() bool {
	if x != nil {
		return x.NewlyRegisteredDomainsEnabled
	}
	return false
}

var File_filecache_proto protoreflect.FileDescriptor

const file_filecache_proto_rawDesc = "" +
	"\n" +
	"\x0ffilecache.proto\x12\tprofiledb\x1a\x1egoogle/protobuf/duration.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\xbb\x01\n" +
	"\tFileCache\x127\n" +
	"\tsync_time\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampR\bsyncTime\x12.\n" +
	"\bprofiles\x18\x02 \x03(\v2\x12.profiledb.ProfileR\bprofiles\x12+\n" +
	"\adevices\x18\x03 \x03(\v2\x11.profiledb.DeviceR\adevices\x12\x18\n" +
	"\aversion\x18\x04 \x01(\x05R\aversion\"\xef\b\n" +
	"\aProfile\x12F\n" +
	"\x0ecustom_domains\x18\x14 \x01(\v2\x1f.profiledb.AccountCustomDomainsR\rcustomDomains\x12<\n" +
	"\rfilter_config\x18\x01 \x01(\v2\x17.profiledb.FilterConfigR\ffilterConfig\x12)\n" +
	"\x06access\x18\x02 \x01(\v2\x11.profiledb.AccessR\x06access\x12X\n" +
	"\x17blocking_mode_custom_ip\x18\x03 \x01(\v2\x1f.profiledb.BlockingModeCustomIPH\x00R\x14blockingModeCustomIp\x12W\n" +
	"\x16blocking_mode_nxdomain\x18\x04 \x01(\v2\x1f.profiledb.BlockingModeNXDOMAINH\x00R\x14blockingModeNxdomain\x12R\n" +
	"\x15blocking_mode_null_ip\x18\x05 \x01(\v2\x1d.profiledb.BlockingModeNullIPH\x00R\x12blockingModeNullIp\x12T\n" +
	"\x15blocking_mode_refused\x18\x06 \x01(\v2\x1e.profiledb.BlockingModeREFUSEDH\x00R\x13blockingModeRefused\x128\n" +
	"\vratelimiter\x18\a \x01(\v2\x16.profiledb.RatelimiterR\vratelimiter\x12\x1d\n" +
	"\n" +
	"account_id\x18\x13 \x01(\tR\taccountId\x12\x1d\n" +
	"\n" +
	"profile_id\x18\b \x01(\tR\tprofileId\x12\x1d\n" +
	"\n" +
	"device_ids\x18\t \x03(\tR\tdeviceIds\x12M\n" +
	"\x15filtered_response_ttl\x18\n" +
	" \x01(\v2\x19.google.protobuf.DurationR\x13filteredResponseTtl\x120\n" +
	"\x14auto_devices_enabled\x18\v \x01(\bR\x12autoDevicesEnabled\x122\n" +
	"\x15block_chrome_prefetch\x18\f \x01(\bR\x13blockChromePrefetch\x120\n" +
	"\x14block_firefox_canary\x18\r \x01(\bR\x12blockFirefoxCanary\x12.\n" +
	"\x13block_private_relay\x18\x0e \x01(\bR\x11blockPrivateRelay\x12\x18\n" +
	"\adeleted\x18\x0f \x01(\bR\adeleted\x12+\n" +
	"\x11filtering_enabled\x18\x10 \x01(\bR\x10filteringEnabled\x12$\n" +
	"\x0eip_log_enabled\x18\x11 \x01(\bR\fipLogEnabled\x12*\n" +
	"\x11query_log_enabled\x18\x12 \x01(\bR\x0fqueryLogEnabledB\x0f\n" +
	"\rblocking_mode\"i\n" +
	"\x14AccountCustomDomains\x127\n" +
	"\adomains\x18\x01 \x03(\v2\x1d.profiledb.CustomDomainConfigR\adomains\x12\x18\n" +
	"\aenabled\x18\x02 \x01(\bR\aenabled\"\x85\x04\n" +
	"\x12CustomDomainConfig\x12Q\n" +
	"\rstate_current\x18\x01 \x01(\v2*.profiledb.CustomDomainConfig.StateCurrentH\x00R\fstateCurrent\x12Q\n" +
	"\rstate_pending\x18\x02 \x01(\v2*.profiledb.CustomDomainConfig.StatePendingH\x00R\fstatePending\x12\x18\n" +
	"\adomains\x18\x03 \x03(\tR\adomains\x1a\xb9\x01\n" +
	"\fStateCurrent\x129\n" +
	"\n" +
	"not_before\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampR\tnotBefore\x127\n" +
	"\tnot_after\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\bnotAfter\x12\x1b\n" +
	"\tcert_name\x18\x03 \x01(\tR\bcertName\x12\x18\n" +
	"\aenabled\x18\x04 \x01(\bR\aenabled\x1aj\n" +
	"\fStatePending\x122\n" +
	"\x06expire\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampR\x06expire\x12&\n" +
	"\x0fwell_known_path\x18\x02 \x01(\tR\rwellKnownPathB\a\n" +
	"\x05state\"\xa9\n" +
	"\n" +
	"\fFilterConfig\x126\n" +
	"\x06custom\x18\x01 \x01(\v2\x1e.profiledb.FilterConfig.CustomR\x06custom\x12<\n" +
	"\bparental\x18\x02 \x01(\v2 .profiledb.FilterConfig.ParentalR\bparental\x12=\n" +
	"\trule_list\x18\x03 \x01(\v2 .profiledb.FilterConfig.RuleListR\bruleList\x12I\n" +
	"\rsafe_browsing\x18\x04 \x01(\v2$.profiledb.FilterConfig.SafeBrowsingR\fsafeBrowsing\x1aD\n" +
	"\x06Custom\x12\x14\n" +
	"\x05rules\x18\x03 \x03(\tR\x05rules\x12\x18\n" +
	"\aenabled\x18\x04 \x01(\bR\aenabledJ\x04\b\x01\x10\x02J\x04\b\x02\x10\x03\x1a\xcc\x02\n" +
	"\bParental\x12G\n" +
	"\x0epause_schedule\x18\x01 \x01(\v2 .profiledb.FilterConfig.ScheduleR\rpauseSchedule\x12)\n" +
	"\x10blocked_services\x18\x02 \x03(\tR\x0fblockedServices\x12\x18\n" +
	"\aenabled\x18\x03 \x01(\bR\aenabled\x124\n" +
	"\x16adult_blocking_enabled\x18\x04 \x01(\bR\x14adultBlockingEnabled\x12=\n" +
	"\x1bsafe_search_general_enabled\x18\x05 \x01(\bR\x18safeSearchGeneralEnabled\x12=\n" +
	"\x1bsafe_search_youtube_enabled\x18\x06 \x01(\bR\x18safeSearchYoutubeEnabled\x1ac\n" +
	"\bSchedule\x12:\n" +
	"\x04week\x18\x01 \x01(\v2&.profiledb.FilterConfig.WeeklyScheduleR\x04week\x12\x1b\n" +
	"\ttime_zone\x18\x02 \x01(\tR\btimeZone\x1a\xb6\x02\n" +
	"\x0eWeeklySchedule\x12(\n" +
	"\x03mon\x18\x01 \x01(\v2\x16.profiledb.DayIntervalR\x03mon\x12(\n" +
	"\x03tue\x18\x02 \x01(\v2\x16.profiledb.DayIntervalR\x03tue\x12(\n" +
	"\x03wed\x18\x03 \x01(\v2\x16.profiledb.DayIntervalR\x03wed\x12(\n" +
	"\x03thu\x18\x04 \x01(\v2\x16.profiledb.DayIntervalR\x03thu\x12(\n" +
	"\x03fri\x18\x05 \x01(\v2\x16.profiledb.DayIntervalR\x03fri\x12(\n" +
	"\x03sat\x18\x06 \x01(\v2\x16.profiledb.DayIntervalR\x03sat\x12(\n" +
	"\x03sun\x18\a \x01(\v2\x16.profiledb.DayIntervalR\x03sun\x1a6\n" +
	"\bRuleList\x12\x10\n" +
	"\x03ids\x18\x01 \x03(\tR\x03ids\x12\x18\n" +
	"\aenabled\x18\x02 \x01(\bR\aenabled\x1a\xad\x01\n" +
	"\fSafeBrowsing\x12\x18\n" +
	"\aenabled\x18\x01 \x01(\bR\aenabled\x12:\n" +
	"\x19dangerous_domains_enabled\x18\x02 \x01(\bR\x17dangerousDomainsEnabled\x12G\n" +
	" newly_registered_domains_enabled\x18\x03 \x01(\bR\x1dnewlyRegisteredDomainsEnabled\"5\n" +
	"\vDayInterval\x12\x14\n" +
	"\x05start\x18\x01 \x01(\rR\x05start\x12\x10\n" +
	"\x03end\x18\x02 \x01(\rR\x03end\">\n" +
	"\x14BlockingModeCustomIP\x12\x12\n" +
	"\x04ipv4\x18\x01 \x03(\fR\x04ipv4\x12\x12\n" +
	"\x04ipv6\x18\x02 \x03(\fR\x04ipv6\"\x16\n" +
	"\x14BlockingModeNXDOMAIN\"\x14\n" +
	"\x12BlockingModeNullIP\"\x15\n" +
	"\x13BlockingModeREFUSED\"\xa6\x02\n" +
	"\x06Device\x12I\n" +
	"\x0eauthentication\x18\x06 \x01(\v2!.profiledb.AuthenticationSettingsR\x0eauthentication\x12\x1b\n" +
	"\tdevice_id\x18\x01 \x01(\tR\bdeviceId\x12\x1f\n" +
	"\vdevice_name\x18\x03 \x01(\tR\n" +
	"deviceName\x12$\n" +
	"\x0ehuman_id_lower\x18\a \x01(\tR\fhumanIdLower\x12\x1b\n" +
	"\tlinked_ip\x18\x02 \x01(\fR\blinkedIp\x12#\n" +
	"\rdedicated_ips\x18\x04 \x03(\fR\fdedicatedIps\x12+\n" +
	"\x11filtering_enabled\x18\x05 \x01(\bR\x10filteringEnabled\"\xad\x02\n" +
	"\x06Access\x12#\n" +
	"\rallowlist_asn\x18\x04 \x03(\rR\fallowlistAsn\x12;\n" +
	"\x0eallowlist_cidr\x18\x01 \x03(\v2\x14.profiledb.CidrRangeR\rallowlistCidr\x12#\n" +
	"\rblocklist_asn\x18\x05 \x03(\rR\fblocklistAsn\x12;\n" +
	"\x0eblocklist_cidr\x18\x02 \x03(\v2\x14.profiledb.CidrRangeR\rblocklistCidr\x124\n" +
	"\x16blocklist_domain_rules\x18\x03 \x03(\tR\x14blocklistDomainRules\x12)\n" +
	"\x10standard_enabled\x18\x06 \x01(\bR\x0fstandardEnabled\"=\n" +
	"\tCidrRange\x12\x18\n" +
	"\aaddress\x18\x01 \x01(\fR\aaddress\x12\x16\n" +
	"\x06prefix\x18\x02 \x01(\rR\x06prefix\"\x85\x01\n" +
	"\x16AuthenticationSettings\x12\"\n" +
	"\rdoh_auth_only\x18\x01 \x01(\bR\vdohAuthOnly\x122\n" +
	"\x14password_hash_bcrypt\x18\x02 \x01(\fH\x00R\x12passwordHashBcryptB\x13\n" +
	"\x11doh_password_hash\"p\n" +
	"\vRatelimiter\x125\n" +
	"\vclient_cidr\x18\x01 \x03(\v2\x14.profiledb.CidrRangeR\n" +
	"clientCidr\x12\x10\n" +
	"\x03rps\x18\x02 \x01(\rR\x03rps\x12\x18\n" +
	"\aenabled\x18\x03 \x01(\bR\aenabledB\x0fZ\r./filecachepbb\x06proto3"

var (
	file_filecache_proto_rawDescOnce sync.Once
	file_filecache_proto_rawDescData []byte
)

func file_filecache_proto_rawDescGZIP() []byte {
	file_filecache_proto_rawDescOnce.Do(func() {
		file_filecache_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_filecache_proto_rawDesc), len(file_filecache_proto_rawDesc)))
	})
	return file_filecache_proto_rawDescData
}

var file_filecache_proto_msgTypes = make([]protoimpl.MessageInfo, 23)
var file_filecache_proto_goTypes = []any{
	(*FileCache)(nil),                       // 0: profiledb.FileCache
	(*Profile)(nil),                         // 1: profiledb.Profile
	(*AccountCustomDomains)(nil),            // 2: profiledb.AccountCustomDomains
	(*CustomDomainConfig)(nil),              // 3: profiledb.CustomDomainConfig
	(*FilterConfig)(nil),                    // 4: profiledb.FilterConfig
	(*DayInterval)(nil),                     // 5: profiledb.DayInterval
	(*BlockingModeCustomIP)(nil),            // 6: profiledb.BlockingModeCustomIP
	(*BlockingModeNXDOMAIN)(nil),            // 7: profiledb.BlockingModeNXDOMAIN
	(*BlockingModeNullIP)(nil),              // 8: profiledb.BlockingModeNullIP
	(*BlockingModeREFUSED)(nil),             // 9: profiledb.BlockingModeREFUSED
	(*Device)(nil),                          // 10: profiledb.Device
	(*Access)(nil),                          // 11: profiledb.Access
	(*CidrRange)(nil),                       // 12: profiledb.CidrRange
	(*AuthenticationSettings)(nil),          // 13: profiledb.AuthenticationSettings
	(*Ratelimiter)(nil),                     // 14: profiledb.Ratelimiter
	(*CustomDomainConfig_StateCurrent)(nil), // 15: profiledb.CustomDomainConfig.StateCurrent
	(*CustomDomainConfig_StatePending)(nil), // 16: profiledb.CustomDomainConfig.StatePending
	(*FilterConfig_Custom)(nil),             // 17: profiledb.FilterConfig.Custom
	(*FilterConfig_Parental)(nil),           // 18: profiledb.FilterConfig.Parental
	(*FilterConfig_Schedule)(nil),           // 19: profiledb.FilterConfig.Schedule
	(*FilterConfig_WeeklySchedule)(nil),     // 20: profiledb.FilterConfig.WeeklySchedule
	(*FilterConfig_RuleList)(nil),           // 21: profiledb.FilterConfig.RuleList
	(*FilterConfig_SafeBrowsing)(nil),       // 22: profiledb.FilterConfig.SafeBrowsing
	(*timestamppb.Timestamp)(nil),           // 23: google.protobuf.Timestamp
	(*durationpb.Duration)(nil),             // 24: google.protobuf.Duration
}
var file_filecache_proto_depIdxs = []int32{
	23, // 0: profiledb.FileCache.sync_time:type_name -> google.protobuf.Timestamp
	1,  // 1: profiledb.FileCache.profiles:type_name -> profiledb.Profile
	10, // 2: profiledb.FileCache.devices:type_name -> profiledb.Device
	2,  // 3: profiledb.Profile.custom_domains:type_name -> profiledb.AccountCustomDomains
	4,  // 4: profiledb.Profile.filter_config:type_name -> profiledb.FilterConfig
	11, // 5: profiledb.Profile.access:type_name -> profiledb.Access
	6,  // 6: profiledb.Profile.blocking_mode_custom_ip:type_name -> profiledb.BlockingModeCustomIP
	7,  // 7: profiledb.Profile.blocking_mode_nxdomain:type_name -> profiledb.BlockingModeNXDOMAIN
	8,  // 8: profiledb.Profile.blocking_mode_null_ip:type_name -> profiledb.BlockingModeNullIP
	9,  // 9: profiledb.Profile.blocking_mode_refused:type_name -> profiledb.BlockingModeREFUSED
	14, // 10: profiledb.Profile.ratelimiter:type_name -> profiledb.Ratelimiter
	24, // 11: profiledb.Profile.filtered_response_ttl:type_name -> google.protobuf.Duration
	3,  // 12: profiledb.AccountCustomDomains.domains:type_name -> profiledb.CustomDomainConfig
	15, // 13: profiledb.CustomDomainConfig.state_current:type_name -> profiledb.CustomDomainConfig.StateCurrent
	16, // 14: profiledb.CustomDomainConfig.state_pending:type_name -> profiledb.CustomDomainConfig.StatePending
	17, // 15: profiledb.FilterConfig.custom:type_name -> profiledb.FilterConfig.Custom
	18, // 16: profiledb.FilterConfig.parental:type_name -> profiledb.FilterConfig.Parental
	21, // 17: profiledb.FilterConfig.rule_list:type_name -> profiledb.FilterConfig.RuleList
	22, // 18: profiledb.FilterConfig.safe_browsing:type_name -> profiledb.FilterConfig.SafeBrowsing
	13, // 19: profiledb.Device.authentication:type_name -> profiledb.AuthenticationSettings
	12, // 20: profiledb.Access.allowlist_cidr:type_name -> profiledb.CidrRange
	12, // 21: profiledb.Access.blocklist_cidr:type_name -> profiledb.CidrRange
	12, // 22: profiledb.Ratelimiter.client_cidr:type_name -> profiledb.CidrRange
	23, // 23: profiledb.CustomDomainConfig.StateCurrent.not_before:type_name -> google.protobuf.Timestamp
	23, // 24: profiledb.CustomDomainConfig.StateCurrent.not_after:type_name -> google.protobuf.Timestamp
	23, // 25: profiledb.CustomDomainConfig.StatePending.expire:type_name -> google.protobuf.Timestamp
	19, // 26: profiledb.FilterConfig.Parental.pause_schedule:type_name -> profiledb.FilterConfig.Schedule
	20, // 27: profiledb.FilterConfig.Schedule.week:type_name -> profiledb.FilterConfig.WeeklySchedule
	5,  // 28: profiledb.FilterConfig.WeeklySchedule.mon:type_name -> profiledb.DayInterval
	5,  // 29: profiledb.FilterConfig.WeeklySchedule.tue:type_name -> profiledb.DayInterval
	5,  // 30: profiledb.FilterConfig.WeeklySchedule.wed:type_name -> profiledb.DayInterval
	5,  // 31: profiledb.FilterConfig.WeeklySchedule.thu:type_name -> profiledb.DayInterval
	5,  // 32: profiledb.FilterConfig.WeeklySchedule.fri:type_name -> profiledb.DayInterval
	5,  // 33: profiledb.FilterConfig.WeeklySchedule.sat:type_name -> profiledb.DayInterval
	5,  // 34: profiledb.FilterConfig.WeeklySchedule.sun:type_name -> profiledb.DayInterval
	35, // [35:35] is the sub-list for method output_type
	35, // [35:35] is the sub-list for method input_type
	35, // [35:35] is the sub-list for extension type_name
	35, // [35:35] is the sub-list for extension extendee
	0,  // [0:35] is the sub-list for field type_name
}

func init() { file_filecache_proto_init() }
func file_filecache_proto_init() {
	if File_filecache_proto != nil {
		return
	}
	file_filecache_proto_msgTypes[1].OneofWrappers = []any{
		(*Profile_BlockingModeCustomIp)(nil),
		(*Profile_BlockingModeNxdomain)(nil),
		(*Profile_BlockingModeNullIp)(nil),
		(*Profile_BlockingModeRefused)(nil),
	}
	file_filecache_proto_msgTypes[3].OneofWrappers = []any{
		(*CustomDomainConfig_StateCurrent_)(nil),
		(*CustomDomainConfig_StatePending_)(nil),
	}
	file_filecache_proto_msgTypes[13].OneofWrappers = []any{
		(*AuthenticationSettings_PasswordHashBcrypt)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_filecache_proto_rawDesc), len(file_filecache_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   23,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_filecache_proto_goTypes,
		DependencyIndexes: file_filecache_proto_depIdxs,
		MessageInfos:      file_filecache_proto_msgTypes,
	}.Build()
	File_filecache_proto = out.File
	file_filecache_proto_goTypes = nil
	file_filecache_proto_depIdxs = nil
}
