// Copyright 2021-2025 Zenauth Ltd.
// SPDX-License-Identifier: Apache-2.0

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.10
// 	protoc        (unknown)
// source: cerbos/telemetry/v1/telemetry.proto

package telemetryv1

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	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 ServerLaunch struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Version       string                 `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	Source        *ServerLaunch_Source   `protobuf:"bytes,2,opt,name=source,proto3" json:"source,omitempty"`
	Features      *ServerLaunch_Features `protobuf:"bytes,3,opt,name=features,proto3" json:"features,omitempty"`
	Stats         *ServerLaunch_Stats    `protobuf:"bytes,4,opt,name=stats,proto3" json:"stats,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ServerLaunch) ProtoMessage() {}

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

func (x *ServerLaunch) GetVersion() string {
	if x != nil {
		return x.Version
	}
	return ""
}

func (x *ServerLaunch) GetSource() *ServerLaunch_Source {
	if x != nil {
		return x.Source
	}
	return nil
}

func (x *ServerLaunch) GetFeatures() *ServerLaunch_Features {
	if x != nil {
		return x.Features
	}
	return nil
}

func (x *ServerLaunch) GetStats() *ServerLaunch_Stats {
	if x != nil {
		return x.Stats
	}
	return nil
}

type ServerStop struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Version       string                 `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	Uptime        *durationpb.Duration   `protobuf:"bytes,2,opt,name=uptime,proto3" json:"uptime,omitempty"`
	RequestsTotal uint64                 `protobuf:"varint,3,opt,name=requests_total,json=requestsTotal,proto3" json:"requests_total,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ServerStop) ProtoMessage() {}

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

func (x *ServerStop) GetVersion() string {
	if x != nil {
		return x.Version
	}
	return ""
}

func (x *ServerStop) GetUptime() *durationpb.Duration {
	if x != nil {
		return x.Uptime
	}
	return nil
}

func (x *ServerStop) GetRequestsTotal() uint64 {
	if x != nil {
		return x.RequestsTotal
	}
	return 0
}

type Event struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Data:
	//
	//	*Event_ApiActivity_
	Data          isEvent_Data `protobuf_oneof:"data"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Event) ProtoMessage() {}

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

func (x *Event) GetData() isEvent_Data {
	if x != nil {
		return x.Data
	}
	return nil
}

func (x *Event) GetApiActivity() *Event_ApiActivity {
	if x != nil {
		if x, ok := x.Data.(*Event_ApiActivity_); ok {
			return x.ApiActivity
		}
	}
	return nil
}

type isEvent_Data interface {
	isEvent_Data()
}

type Event_ApiActivity_ struct {
	ApiActivity *Event_ApiActivity `protobuf:"bytes,1,opt,name=api_activity,json=apiActivity,proto3,oneof"`
}

func (*Event_ApiActivity_) isEvent_Data() {}

type ServerLaunch_Cerbos struct {
	state          protoimpl.MessageState `protogen:"open.v1"`
	Version        string                 `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	Commit         string                 `protobuf:"bytes,2,opt,name=commit,proto3" json:"commit,omitempty"`
	BuildDate      string                 `protobuf:"bytes,3,opt,name=build_date,json=buildDate,proto3" json:"build_date,omitempty"`
	ModuleVersion  string                 `protobuf:"bytes,4,opt,name=module_version,json=moduleVersion,proto3" json:"module_version,omitempty"`
	ModuleChecksum string                 `protobuf:"bytes,5,opt,name=module_checksum,json=moduleChecksum,proto3" json:"module_checksum,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*ServerLaunch_Cerbos) ProtoMessage() {}

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

func (x *ServerLaunch_Cerbos) GetVersion() string {
	if x != nil {
		return x.Version
	}
	return ""
}

func (x *ServerLaunch_Cerbos) GetCommit() string {
	if x != nil {
		return x.Commit
	}
	return ""
}

func (x *ServerLaunch_Cerbos) GetBuildDate() string {
	if x != nil {
		return x.BuildDate
	}
	return ""
}

func (x *ServerLaunch_Cerbos) GetModuleVersion() string {
	if x != nil {
		return x.ModuleVersion
	}
	return ""
}

func (x *ServerLaunch_Cerbos) GetModuleChecksum() string {
	if x != nil {
		return x.ModuleChecksum
	}
	return ""
}

type ServerLaunch_Source struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Cerbos        *ServerLaunch_Cerbos   `protobuf:"bytes,1,opt,name=cerbos,proto3" json:"cerbos,omitempty"`
	Os            string                 `protobuf:"bytes,2,opt,name=os,proto3" json:"os,omitempty"`
	Arch          string                 `protobuf:"bytes,3,opt,name=arch,proto3" json:"arch,omitempty"`
	NumCpus       uint32                 `protobuf:"varint,4,opt,name=num_cpus,json=numCpus,proto3" json:"num_cpus,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ServerLaunch_Source) ProtoMessage() {}

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

func (x *ServerLaunch_Source) GetCerbos() *ServerLaunch_Cerbos {
	if x != nil {
		return x.Cerbos
	}
	return nil
}

func (x *ServerLaunch_Source) GetOs() string {
	if x != nil {
		return x.Os
	}
	return ""
}

func (x *ServerLaunch_Source) GetArch() string {
	if x != nil {
		return x.Arch
	}
	return ""
}

func (x *ServerLaunch_Source) GetNumCpus() uint32 {
	if x != nil {
		return x.NumCpus
	}
	return 0
}

type ServerLaunch_Features struct {
	state         protoimpl.MessageState          `protogen:"open.v1"`
	Audit         *ServerLaunch_Features_Audit    `protobuf:"bytes,1,opt,name=audit,proto3" json:"audit,omitempty"`
	Schema        *ServerLaunch_Features_Schema   `protobuf:"bytes,2,opt,name=schema,proto3" json:"schema,omitempty"`
	AdminApi      *ServerLaunch_Features_AdminApi `protobuf:"bytes,3,opt,name=admin_api,json=adminApi,proto3" json:"admin_api,omitempty"`
	Storage       *ServerLaunch_Features_Storage  `protobuf:"bytes,4,opt,name=storage,proto3" json:"storage,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ServerLaunch_Features) ProtoMessage() {}

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

func (x *ServerLaunch_Features) GetAudit() *ServerLaunch_Features_Audit {
	if x != nil {
		return x.Audit
	}
	return nil
}

func (x *ServerLaunch_Features) GetSchema() *ServerLaunch_Features_Schema {
	if x != nil {
		return x.Schema
	}
	return nil
}

func (x *ServerLaunch_Features) GetAdminApi() *ServerLaunch_Features_AdminApi {
	if x != nil {
		return x.AdminApi
	}
	return nil
}

func (x *ServerLaunch_Features) GetStorage() *ServerLaunch_Features_Storage {
	if x != nil {
		return x.Storage
	}
	return nil
}

type ServerLaunch_Stats struct {
	state         protoimpl.MessageState     `protogen:"open.v1"`
	Policy        *ServerLaunch_Stats_Policy `protobuf:"bytes,1,opt,name=policy,proto3" json:"policy,omitempty"`
	Schema        *ServerLaunch_Stats_Schema `protobuf:"bytes,2,opt,name=schema,proto3" json:"schema,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ServerLaunch_Stats) ProtoMessage() {}

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

func (x *ServerLaunch_Stats) GetPolicy() *ServerLaunch_Stats_Policy {
	if x != nil {
		return x.Policy
	}
	return nil
}

func (x *ServerLaunch_Stats) GetSchema() *ServerLaunch_Stats_Schema {
	if x != nil {
		return x.Schema
	}
	return nil
}

type ServerLaunch_Features_Audit struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Enabled       bool                   `protobuf:"varint,1,opt,name=enabled,proto3" json:"enabled,omitempty"`
	Backend       string                 `protobuf:"bytes,2,opt,name=backend,proto3" json:"backend,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ServerLaunch_Features_Audit) ProtoMessage() {}

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

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

func (x *ServerLaunch_Features_Audit) GetBackend() string {
	if x != nil {
		return x.Backend
	}
	return ""
}

type ServerLaunch_Features_Schema struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Enforcement   string                 `protobuf:"bytes,1,opt,name=enforcement,proto3" json:"enforcement,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ServerLaunch_Features_Schema) ProtoMessage() {}

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

func (x *ServerLaunch_Features_Schema) GetEnforcement() string {
	if x != nil {
		return x.Enforcement
	}
	return ""
}

type ServerLaunch_Features_AdminApi struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Enabled       bool                   `protobuf:"varint,1,opt,name=enabled,proto3" json:"enabled,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ServerLaunch_Features_AdminApi) ProtoMessage() {}

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

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

type ServerLaunch_Features_Storage struct {
	state  protoimpl.MessageState `protogen:"open.v1"`
	Driver string                 `protobuf:"bytes,1,opt,name=driver,proto3" json:"driver,omitempty"`
	// Types that are valid to be assigned to Store:
	//
	//	*ServerLaunch_Features_Storage_Disk_
	//	*ServerLaunch_Features_Storage_Git_
	//	*ServerLaunch_Features_Storage_Blob_
	//	*ServerLaunch_Features_Storage_Bundle_
	Store         isServerLaunch_Features_Storage_Store `protobuf_oneof:"store"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ServerLaunch_Features_Storage) ProtoMessage() {}

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

func (x *ServerLaunch_Features_Storage) GetDriver() string {
	if x != nil {
		return x.Driver
	}
	return ""
}

func (x *ServerLaunch_Features_Storage) GetStore() isServerLaunch_Features_Storage_Store {
	if x != nil {
		return x.Store
	}
	return nil
}

func (x *ServerLaunch_Features_Storage) GetDisk() *ServerLaunch_Features_Storage_Disk {
	if x != nil {
		if x, ok := x.Store.(*ServerLaunch_Features_Storage_Disk_); ok {
			return x.Disk
		}
	}
	return nil
}

func (x *ServerLaunch_Features_Storage) GetGit() *ServerLaunch_Features_Storage_Git {
	if x != nil {
		if x, ok := x.Store.(*ServerLaunch_Features_Storage_Git_); ok {
			return x.Git
		}
	}
	return nil
}

func (x *ServerLaunch_Features_Storage) GetBlob() *ServerLaunch_Features_Storage_Blob {
	if x != nil {
		if x, ok := x.Store.(*ServerLaunch_Features_Storage_Blob_); ok {
			return x.Blob
		}
	}
	return nil
}

func (x *ServerLaunch_Features_Storage) GetBundle() *ServerLaunch_Features_Storage_Bundle {
	if x != nil {
		if x, ok := x.Store.(*ServerLaunch_Features_Storage_Bundle_); ok {
			return x.Bundle
		}
	}
	return nil
}

type isServerLaunch_Features_Storage_Store interface {
	isServerLaunch_Features_Storage_Store()
}

type ServerLaunch_Features_Storage_Disk_ struct {
	Disk *ServerLaunch_Features_Storage_Disk `protobuf:"bytes,2,opt,name=disk,proto3,oneof"`
}

type ServerLaunch_Features_Storage_Git_ struct {
	Git *ServerLaunch_Features_Storage_Git `protobuf:"bytes,3,opt,name=git,proto3,oneof"`
}

type ServerLaunch_Features_Storage_Blob_ struct {
	Blob *ServerLaunch_Features_Storage_Blob `protobuf:"bytes,4,opt,name=blob,proto3,oneof"`
}

type ServerLaunch_Features_Storage_Bundle_ struct {
	Bundle *ServerLaunch_Features_Storage_Bundle `protobuf:"bytes,5,opt,name=bundle,proto3,oneof"`
}

func (*ServerLaunch_Features_Storage_Disk_) isServerLaunch_Features_Storage_Store() {}

func (*ServerLaunch_Features_Storage_Git_) isServerLaunch_Features_Storage_Store() {}

func (*ServerLaunch_Features_Storage_Blob_) isServerLaunch_Features_Storage_Store() {}

func (*ServerLaunch_Features_Storage_Bundle_) isServerLaunch_Features_Storage_Store() {}

type ServerLaunch_Features_Storage_Disk struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Watch         bool                   `protobuf:"varint,1,opt,name=watch,proto3" json:"watch,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ServerLaunch_Features_Storage_Disk) ProtoMessage() {}

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

func (x *ServerLaunch_Features_Storage_Disk) GetWatch() bool {
	if x != nil {
		return x.Watch
	}
	return false
}

type ServerLaunch_Features_Storage_Git struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Protocol      string                 `protobuf:"bytes,1,opt,name=protocol,proto3" json:"protocol,omitempty"`
	Auth          bool                   `protobuf:"varint,2,opt,name=auth,proto3" json:"auth,omitempty"`
	PollInterval  *durationpb.Duration   `protobuf:"bytes,3,opt,name=poll_interval,json=pollInterval,proto3" json:"poll_interval,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ServerLaunch_Features_Storage_Git) ProtoMessage() {}

func (x *ServerLaunch_Features_Storage_Git) ProtoReflect() protoreflect.Message {
	mi := &file_cerbos_telemetry_v1_telemetry_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 ServerLaunch_Features_Storage_Git.ProtoReflect.Descriptor instead.
func (*ServerLaunch_Features_Storage_Git) Descriptor() ([]byte, []int) {
	return file_cerbos_telemetry_v1_telemetry_proto_rawDescGZIP(), []int{0, 2, 3, 1}
}

func (x *ServerLaunch_Features_Storage_Git) GetProtocol() string {
	if x != nil {
		return x.Protocol
	}
	return ""
}

func (x *ServerLaunch_Features_Storage_Git) GetAuth() bool {
	if x != nil {
		return x.Auth
	}
	return false
}

func (x *ServerLaunch_Features_Storage_Git) GetPollInterval() *durationpb.Duration {
	if x != nil {
		return x.PollInterval
	}
	return nil
}

type ServerLaunch_Features_Storage_Blob struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Provider      string                 `protobuf:"bytes,1,opt,name=provider,proto3" json:"provider,omitempty"`
	PollInterval  *durationpb.Duration   `protobuf:"bytes,2,opt,name=poll_interval,json=pollInterval,proto3" json:"poll_interval,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ServerLaunch_Features_Storage_Blob) ProtoMessage() {}

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

func (x *ServerLaunch_Features_Storage_Blob) GetProvider() string {
	if x != nil {
		return x.Provider
	}
	return ""
}

func (x *ServerLaunch_Features_Storage_Blob) GetPollInterval() *durationpb.Duration {
	if x != nil {
		return x.PollInterval
	}
	return nil
}

type ServerLaunch_Features_Storage_Bundle struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	PdpId         string                 `protobuf:"bytes,1,opt,name=pdp_id,json=pdpId,proto3" json:"pdp_id,omitempty"`
	BundleSource  string                 `protobuf:"bytes,2,opt,name=bundle_source,json=bundleSource,proto3" json:"bundle_source,omitempty"`
	ClientId      string                 `protobuf:"bytes,3,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ServerLaunch_Features_Storage_Bundle) ProtoMessage() {}

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

func (x *ServerLaunch_Features_Storage_Bundle) GetPdpId() string {
	if x != nil {
		return x.PdpId
	}
	return ""
}

func (x *ServerLaunch_Features_Storage_Bundle) GetBundleSource() string {
	if x != nil {
		return x.BundleSource
	}
	return ""
}

func (x *ServerLaunch_Features_Storage_Bundle) GetClientId() string {
	if x != nil {
		return x.ClientId
	}
	return ""
}

type ServerLaunch_Stats_Policy struct {
	state             protoimpl.MessageState `protogen:"open.v1"`
	Count             map[string]uint32      `protobuf:"bytes,1,rep,name=count,proto3" json:"count,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
	AvgRuleCount      map[string]float64     `protobuf:"bytes,2,rep,name=avg_rule_count,json=avgRuleCount,proto3" json:"avg_rule_count,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
	AvgConditionCount map[string]float64     `protobuf:"bytes,3,rep,name=avg_condition_count,json=avgConditionCount,proto3" json:"avg_condition_count,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
	unknownFields     protoimpl.UnknownFields
	sizeCache         protoimpl.SizeCache
}

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

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

func (*ServerLaunch_Stats_Policy) ProtoMessage() {}

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

func (x *ServerLaunch_Stats_Policy) GetCount() map[string]uint32 {
	if x != nil {
		return x.Count
	}
	return nil
}

func (x *ServerLaunch_Stats_Policy) GetAvgRuleCount() map[string]float64 {
	if x != nil {
		return x.AvgRuleCount
	}
	return nil
}

func (x *ServerLaunch_Stats_Policy) GetAvgConditionCount() map[string]float64 {
	if x != nil {
		return x.AvgConditionCount
	}
	return nil
}

type ServerLaunch_Stats_Schema struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Count         uint32                 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ServerLaunch_Stats_Schema) ProtoMessage() {}

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

func (x *ServerLaunch_Stats_Schema) GetCount() uint32 {
	if x != nil {
		return x.Count
	}
	return 0
}

type Event_CountStat struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Key           string                 `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Count         uint64                 `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Event_CountStat) ProtoMessage() {}

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

func (x *Event_CountStat) GetKey() string {
	if x != nil {
		return x.Key
	}
	return ""
}

func (x *Event_CountStat) GetCount() uint64 {
	if x != nil {
		return x.Count
	}
	return 0
}

type Event_ApiActivity struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Version       string                 `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	Uptime        *durationpb.Duration   `protobuf:"bytes,2,opt,name=uptime,proto3" json:"uptime,omitempty"`
	MethodCalls   []*Event_CountStat     `protobuf:"bytes,3,rep,name=method_calls,json=methodCalls,proto3" json:"method_calls,omitempty"`
	UserAgents    []*Event_CountStat     `protobuf:"bytes,4,rep,name=user_agents,json=userAgents,proto3" json:"user_agents,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Event_ApiActivity) ProtoMessage() {}

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

func (x *Event_ApiActivity) GetVersion() string {
	if x != nil {
		return x.Version
	}
	return ""
}

func (x *Event_ApiActivity) GetUptime() *durationpb.Duration {
	if x != nil {
		return x.Uptime
	}
	return nil
}

func (x *Event_ApiActivity) GetMethodCalls() []*Event_CountStat {
	if x != nil {
		return x.MethodCalls
	}
	return nil
}

func (x *Event_ApiActivity) GetUserAgents() []*Event_CountStat {
	if x != nil {
		return x.UserAgents
	}
	return nil
}

var File_cerbos_telemetry_v1_telemetry_proto protoreflect.FileDescriptor

const file_cerbos_telemetry_v1_telemetry_proto_rawDesc = "" +
	"\n" +
	"#cerbos/telemetry/v1/telemetry.proto\x12\x13cerbos.telemetry.v1\x1a\x1egoogle/protobuf/duration.proto\"\xf6\x12\n" +
	"\fServerLaunch\x12\x18\n" +
	"\aversion\x18\x01 \x01(\tR\aversion\x12@\n" +
	"\x06source\x18\x02 \x01(\v2(.cerbos.telemetry.v1.ServerLaunch.SourceR\x06source\x12F\n" +
	"\bfeatures\x18\x03 \x01(\v2*.cerbos.telemetry.v1.ServerLaunch.FeaturesR\bfeatures\x12=\n" +
	"\x05stats\x18\x04 \x01(\v2'.cerbos.telemetry.v1.ServerLaunch.StatsR\x05stats\x1a\xa9\x01\n" +
	"\x06Cerbos\x12\x18\n" +
	"\aversion\x18\x01 \x01(\tR\aversion\x12\x16\n" +
	"\x06commit\x18\x02 \x01(\tR\x06commit\x12\x1d\n" +
	"\n" +
	"build_date\x18\x03 \x01(\tR\tbuildDate\x12%\n" +
	"\x0emodule_version\x18\x04 \x01(\tR\rmoduleVersion\x12'\n" +
	"\x0fmodule_checksum\x18\x05 \x01(\tR\x0emoduleChecksum\x1a\x89\x01\n" +
	"\x06Source\x12@\n" +
	"\x06cerbos\x18\x01 \x01(\v2(.cerbos.telemetry.v1.ServerLaunch.CerbosR\x06cerbos\x12\x0e\n" +
	"\x02os\x18\x02 \x01(\tR\x02os\x12\x12\n" +
	"\x04arch\x18\x03 \x01(\tR\x04arch\x12\x19\n" +
	"\bnum_cpus\x18\x04 \x01(\rR\anumCpus\x1a\x94\t\n" +
	"\bFeatures\x12F\n" +
	"\x05audit\x18\x01 \x01(\v20.cerbos.telemetry.v1.ServerLaunch.Features.AuditR\x05audit\x12I\n" +
	"\x06schema\x18\x02 \x01(\v21.cerbos.telemetry.v1.ServerLaunch.Features.SchemaR\x06schema\x12P\n" +
	"\tadmin_api\x18\x03 \x01(\v23.cerbos.telemetry.v1.ServerLaunch.Features.AdminApiR\badminApi\x12L\n" +
	"\astorage\x18\x04 \x01(\v22.cerbos.telemetry.v1.ServerLaunch.Features.StorageR\astorage\x1a;\n" +
	"\x05Audit\x12\x18\n" +
	"\aenabled\x18\x01 \x01(\bR\aenabled\x12\x18\n" +
	"\abackend\x18\x02 \x01(\tR\abackend\x1a*\n" +
	"\x06Schema\x12 \n" +
	"\venforcement\x18\x01 \x01(\tR\venforcement\x1a$\n" +
	"\bAdminApi\x12\x18\n" +
	"\aenabled\x18\x01 \x01(\bR\aenabled\x1a\xc5\x05\n" +
	"\aStorage\x12\x16\n" +
	"\x06driver\x18\x01 \x01(\tR\x06driver\x12M\n" +
	"\x04disk\x18\x02 \x01(\v27.cerbos.telemetry.v1.ServerLaunch.Features.Storage.DiskH\x00R\x04disk\x12J\n" +
	"\x03git\x18\x03 \x01(\v26.cerbos.telemetry.v1.ServerLaunch.Features.Storage.GitH\x00R\x03git\x12M\n" +
	"\x04blob\x18\x04 \x01(\v27.cerbos.telemetry.v1.ServerLaunch.Features.Storage.BlobH\x00R\x04blob\x12S\n" +
	"\x06bundle\x18\x05 \x01(\v29.cerbos.telemetry.v1.ServerLaunch.Features.Storage.BundleH\x00R\x06bundle\x1a\x1c\n" +
	"\x04Disk\x12\x14\n" +
	"\x05watch\x18\x01 \x01(\bR\x05watch\x1au\n" +
	"\x03Git\x12\x1a\n" +
	"\bprotocol\x18\x01 \x01(\tR\bprotocol\x12\x12\n" +
	"\x04auth\x18\x02 \x01(\bR\x04auth\x12>\n" +
	"\rpoll_interval\x18\x03 \x01(\v2\x19.google.protobuf.DurationR\fpollInterval\x1ab\n" +
	"\x04Blob\x12\x1a\n" +
	"\bprovider\x18\x01 \x01(\tR\bprovider\x12>\n" +
	"\rpoll_interval\x18\x02 \x01(\v2\x19.google.protobuf.DurationR\fpollInterval\x1aa\n" +
	"\x06Bundle\x12\x15\n" +
	"\x06pdp_id\x18\x01 \x01(\tR\x05pdpId\x12#\n" +
	"\rbundle_source\x18\x02 \x01(\tR\fbundleSource\x12\x1b\n" +
	"\tclient_id\x18\x03 \x01(\tR\bclientIdB\a\n" +
	"\x05store\x1a\xb3\x05\n" +
	"\x05Stats\x12F\n" +
	"\x06policy\x18\x01 \x01(\v2..cerbos.telemetry.v1.ServerLaunch.Stats.PolicyR\x06policy\x12F\n" +
	"\x06schema\x18\x02 \x01(\v2..cerbos.telemetry.v1.ServerLaunch.Stats.SchemaR\x06schema\x1a\xf9\x03\n" +
	"\x06Policy\x12O\n" +
	"\x05count\x18\x01 \x03(\v29.cerbos.telemetry.v1.ServerLaunch.Stats.Policy.CountEntryR\x05count\x12f\n" +
	"\x0eavg_rule_count\x18\x02 \x03(\v2@.cerbos.telemetry.v1.ServerLaunch.Stats.Policy.AvgRuleCountEntryR\favgRuleCount\x12u\n" +
	"\x13avg_condition_count\x18\x03 \x03(\v2E.cerbos.telemetry.v1.ServerLaunch.Stats.Policy.AvgConditionCountEntryR\x11avgConditionCount\x1a8\n" +
	"\n" +
	"CountEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\rR\x05value:\x028\x01\x1a?\n" +
	"\x11AvgRuleCountEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x01R\x05value:\x028\x01\x1aD\n" +
	"\x16AvgConditionCountEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x01R\x05value:\x028\x01\x1a\x1e\n" +
	"\x06Schema\x12\x14\n" +
	"\x05count\x18\x01 \x01(\rR\x05count\"\x80\x01\n" +
	"\n" +
	"ServerStop\x12\x18\n" +
	"\aversion\x18\x01 \x01(\tR\aversion\x121\n" +
	"\x06uptime\x18\x02 \x01(\v2\x19.google.protobuf.DurationR\x06uptime\x12%\n" +
	"\x0erequests_total\x18\x03 \x01(\x04R\rrequestsTotal\"\xfe\x02\n" +
	"\x05Event\x12K\n" +
	"\fapi_activity\x18\x01 \x01(\v2&.cerbos.telemetry.v1.Event.ApiActivityH\x00R\vapiActivity\x1a3\n" +
	"\tCountStat\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05count\x18\x02 \x01(\x04R\x05count\x1a\xea\x01\n" +
	"\vApiActivity\x12\x18\n" +
	"\aversion\x18\x01 \x01(\tR\aversion\x121\n" +
	"\x06uptime\x18\x02 \x01(\v2\x19.google.protobuf.DurationR\x06uptime\x12G\n" +
	"\fmethod_calls\x18\x03 \x03(\v2$.cerbos.telemetry.v1.Event.CountStatR\vmethodCalls\x12E\n" +
	"\vuser_agents\x18\x04 \x03(\v2$.cerbos.telemetry.v1.Event.CountStatR\n" +
	"userAgentsB\x06\n" +
	"\x04dataB{\n" +
	"\x1bdev.cerbos.api.v1.telemetryZBgithub.com/cerbos/cerbos/api/genpb/cerbos/telemetry/v1;telemetryv1\xaa\x02\x17Cerbos.Api.V1.Telemetryb\x06proto3"

var (
	file_cerbos_telemetry_v1_telemetry_proto_rawDescOnce sync.Once
	file_cerbos_telemetry_v1_telemetry_proto_rawDescData []byte
)

func file_cerbos_telemetry_v1_telemetry_proto_rawDescGZIP() []byte {
	file_cerbos_telemetry_v1_telemetry_proto_rawDescOnce.Do(func() {
		file_cerbos_telemetry_v1_telemetry_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_cerbos_telemetry_v1_telemetry_proto_rawDesc), len(file_cerbos_telemetry_v1_telemetry_proto_rawDesc)))
	})
	return file_cerbos_telemetry_v1_telemetry_proto_rawDescData
}

var file_cerbos_telemetry_v1_telemetry_proto_msgTypes = make([]protoimpl.MessageInfo, 22)
var file_cerbos_telemetry_v1_telemetry_proto_goTypes = []any{
	(*ServerLaunch)(nil),                         // 0: cerbos.telemetry.v1.ServerLaunch
	(*ServerStop)(nil),                           // 1: cerbos.telemetry.v1.ServerStop
	(*Event)(nil),                                // 2: cerbos.telemetry.v1.Event
	(*ServerLaunch_Cerbos)(nil),                  // 3: cerbos.telemetry.v1.ServerLaunch.Cerbos
	(*ServerLaunch_Source)(nil),                  // 4: cerbos.telemetry.v1.ServerLaunch.Source
	(*ServerLaunch_Features)(nil),                // 5: cerbos.telemetry.v1.ServerLaunch.Features
	(*ServerLaunch_Stats)(nil),                   // 6: cerbos.telemetry.v1.ServerLaunch.Stats
	(*ServerLaunch_Features_Audit)(nil),          // 7: cerbos.telemetry.v1.ServerLaunch.Features.Audit
	(*ServerLaunch_Features_Schema)(nil),         // 8: cerbos.telemetry.v1.ServerLaunch.Features.Schema
	(*ServerLaunch_Features_AdminApi)(nil),       // 9: cerbos.telemetry.v1.ServerLaunch.Features.AdminApi
	(*ServerLaunch_Features_Storage)(nil),        // 10: cerbos.telemetry.v1.ServerLaunch.Features.Storage
	(*ServerLaunch_Features_Storage_Disk)(nil),   // 11: cerbos.telemetry.v1.ServerLaunch.Features.Storage.Disk
	(*ServerLaunch_Features_Storage_Git)(nil),    // 12: cerbos.telemetry.v1.ServerLaunch.Features.Storage.Git
	(*ServerLaunch_Features_Storage_Blob)(nil),   // 13: cerbos.telemetry.v1.ServerLaunch.Features.Storage.Blob
	(*ServerLaunch_Features_Storage_Bundle)(nil), // 14: cerbos.telemetry.v1.ServerLaunch.Features.Storage.Bundle
	(*ServerLaunch_Stats_Policy)(nil),            // 15: cerbos.telemetry.v1.ServerLaunch.Stats.Policy
	(*ServerLaunch_Stats_Schema)(nil),            // 16: cerbos.telemetry.v1.ServerLaunch.Stats.Schema
	nil,                                          // 17: cerbos.telemetry.v1.ServerLaunch.Stats.Policy.CountEntry
	nil,                                          // 18: cerbos.telemetry.v1.ServerLaunch.Stats.Policy.AvgRuleCountEntry
	nil,                                          // 19: cerbos.telemetry.v1.ServerLaunch.Stats.Policy.AvgConditionCountEntry
	(*Event_CountStat)(nil),                      // 20: cerbos.telemetry.v1.Event.CountStat
	(*Event_ApiActivity)(nil),                    // 21: cerbos.telemetry.v1.Event.ApiActivity
	(*durationpb.Duration)(nil),                  // 22: google.protobuf.Duration
}
var file_cerbos_telemetry_v1_telemetry_proto_depIdxs = []int32{
	4,  // 0: cerbos.telemetry.v1.ServerLaunch.source:type_name -> cerbos.telemetry.v1.ServerLaunch.Source
	5,  // 1: cerbos.telemetry.v1.ServerLaunch.features:type_name -> cerbos.telemetry.v1.ServerLaunch.Features
	6,  // 2: cerbos.telemetry.v1.ServerLaunch.stats:type_name -> cerbos.telemetry.v1.ServerLaunch.Stats
	22, // 3: cerbos.telemetry.v1.ServerStop.uptime:type_name -> google.protobuf.Duration
	21, // 4: cerbos.telemetry.v1.Event.api_activity:type_name -> cerbos.telemetry.v1.Event.ApiActivity
	3,  // 5: cerbos.telemetry.v1.ServerLaunch.Source.cerbos:type_name -> cerbos.telemetry.v1.ServerLaunch.Cerbos
	7,  // 6: cerbos.telemetry.v1.ServerLaunch.Features.audit:type_name -> cerbos.telemetry.v1.ServerLaunch.Features.Audit
	8,  // 7: cerbos.telemetry.v1.ServerLaunch.Features.schema:type_name -> cerbos.telemetry.v1.ServerLaunch.Features.Schema
	9,  // 8: cerbos.telemetry.v1.ServerLaunch.Features.admin_api:type_name -> cerbos.telemetry.v1.ServerLaunch.Features.AdminApi
	10, // 9: cerbos.telemetry.v1.ServerLaunch.Features.storage:type_name -> cerbos.telemetry.v1.ServerLaunch.Features.Storage
	15, // 10: cerbos.telemetry.v1.ServerLaunch.Stats.policy:type_name -> cerbos.telemetry.v1.ServerLaunch.Stats.Policy
	16, // 11: cerbos.telemetry.v1.ServerLaunch.Stats.schema:type_name -> cerbos.telemetry.v1.ServerLaunch.Stats.Schema
	11, // 12: cerbos.telemetry.v1.ServerLaunch.Features.Storage.disk:type_name -> cerbos.telemetry.v1.ServerLaunch.Features.Storage.Disk
	12, // 13: cerbos.telemetry.v1.ServerLaunch.Features.Storage.git:type_name -> cerbos.telemetry.v1.ServerLaunch.Features.Storage.Git
	13, // 14: cerbos.telemetry.v1.ServerLaunch.Features.Storage.blob:type_name -> cerbos.telemetry.v1.ServerLaunch.Features.Storage.Blob
	14, // 15: cerbos.telemetry.v1.ServerLaunch.Features.Storage.bundle:type_name -> cerbos.telemetry.v1.ServerLaunch.Features.Storage.Bundle
	22, // 16: cerbos.telemetry.v1.ServerLaunch.Features.Storage.Git.poll_interval:type_name -> google.protobuf.Duration
	22, // 17: cerbos.telemetry.v1.ServerLaunch.Features.Storage.Blob.poll_interval:type_name -> google.protobuf.Duration
	17, // 18: cerbos.telemetry.v1.ServerLaunch.Stats.Policy.count:type_name -> cerbos.telemetry.v1.ServerLaunch.Stats.Policy.CountEntry
	18, // 19: cerbos.telemetry.v1.ServerLaunch.Stats.Policy.avg_rule_count:type_name -> cerbos.telemetry.v1.ServerLaunch.Stats.Policy.AvgRuleCountEntry
	19, // 20: cerbos.telemetry.v1.ServerLaunch.Stats.Policy.avg_condition_count:type_name -> cerbos.telemetry.v1.ServerLaunch.Stats.Policy.AvgConditionCountEntry
	22, // 21: cerbos.telemetry.v1.Event.ApiActivity.uptime:type_name -> google.protobuf.Duration
	20, // 22: cerbos.telemetry.v1.Event.ApiActivity.method_calls:type_name -> cerbos.telemetry.v1.Event.CountStat
	20, // 23: cerbos.telemetry.v1.Event.ApiActivity.user_agents:type_name -> cerbos.telemetry.v1.Event.CountStat
	24, // [24:24] is the sub-list for method output_type
	24, // [24:24] is the sub-list for method input_type
	24, // [24:24] is the sub-list for extension type_name
	24, // [24:24] is the sub-list for extension extendee
	0,  // [0:24] is the sub-list for field type_name
}

func init() { file_cerbos_telemetry_v1_telemetry_proto_init() }
func file_cerbos_telemetry_v1_telemetry_proto_init() {
	if File_cerbos_telemetry_v1_telemetry_proto != nil {
		return
	}
	file_cerbos_telemetry_v1_telemetry_proto_msgTypes[2].OneofWrappers = []any{
		(*Event_ApiActivity_)(nil),
	}
	file_cerbos_telemetry_v1_telemetry_proto_msgTypes[10].OneofWrappers = []any{
		(*ServerLaunch_Features_Storage_Disk_)(nil),
		(*ServerLaunch_Features_Storage_Git_)(nil),
		(*ServerLaunch_Features_Storage_Blob_)(nil),
		(*ServerLaunch_Features_Storage_Bundle_)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_cerbos_telemetry_v1_telemetry_proto_rawDesc), len(file_cerbos_telemetry_v1_telemetry_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   22,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_cerbos_telemetry_v1_telemetry_proto_goTypes,
		DependencyIndexes: file_cerbos_telemetry_v1_telemetry_proto_depIdxs,
		MessageInfos:      file_cerbos_telemetry_v1_telemetry_proto_msgTypes,
	}.Build()
	File_cerbos_telemetry_v1_telemetry_proto = out.File
	file_cerbos_telemetry_v1_telemetry_proto_goTypes = nil
	file_cerbos_telemetry_v1_telemetry_proto_depIdxs = nil
}
