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

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

package svcv1

import (
	context "context"
	v1 "github.com/cerbos/cerbos/api/genpb/cerbos/request/v1"
	v11 "github.com/cerbos/cerbos/api/genpb/cerbos/response/v1"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.64.0 or later.
const _ = grpc.SupportPackageIsVersion9

const (
	CerbosService_CheckResourceSet_FullMethodName   = "/cerbos.svc.v1.CerbosService/CheckResourceSet"
	CerbosService_CheckResourceBatch_FullMethodName = "/cerbos.svc.v1.CerbosService/CheckResourceBatch"
	CerbosService_CheckResources_FullMethodName     = "/cerbos.svc.v1.CerbosService/CheckResources"
	CerbosService_ServerInfo_FullMethodName         = "/cerbos.svc.v1.CerbosService/ServerInfo"
	CerbosService_PlanResources_FullMethodName      = "/cerbos.svc.v1.CerbosService/PlanResources"
)

// CerbosServiceClient is the client API for CerbosService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type CerbosServiceClient interface {
	CheckResourceSet(ctx context.Context, in *v1.CheckResourceSetRequest, opts ...grpc.CallOption) (*v11.CheckResourceSetResponse, error)
	CheckResourceBatch(ctx context.Context, in *v1.CheckResourceBatchRequest, opts ...grpc.CallOption) (*v11.CheckResourceBatchResponse, error)
	CheckResources(ctx context.Context, in *v1.CheckResourcesRequest, opts ...grpc.CallOption) (*v11.CheckResourcesResponse, error)
	ServerInfo(ctx context.Context, in *v1.ServerInfoRequest, opts ...grpc.CallOption) (*v11.ServerInfoResponse, error)
	PlanResources(ctx context.Context, in *v1.PlanResourcesRequest, opts ...grpc.CallOption) (*v11.PlanResourcesResponse, error)
}

type cerbosServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewCerbosServiceClient(cc grpc.ClientConnInterface) CerbosServiceClient {
	return &cerbosServiceClient{cc}
}

func (c *cerbosServiceClient) CheckResourceSet(ctx context.Context, in *v1.CheckResourceSetRequest, opts ...grpc.CallOption) (*v11.CheckResourceSetResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v11.CheckResourceSetResponse)
	err := c.cc.Invoke(ctx, CerbosService_CheckResourceSet_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cerbosServiceClient) CheckResourceBatch(ctx context.Context, in *v1.CheckResourceBatchRequest, opts ...grpc.CallOption) (*v11.CheckResourceBatchResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v11.CheckResourceBatchResponse)
	err := c.cc.Invoke(ctx, CerbosService_CheckResourceBatch_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cerbosServiceClient) CheckResources(ctx context.Context, in *v1.CheckResourcesRequest, opts ...grpc.CallOption) (*v11.CheckResourcesResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v11.CheckResourcesResponse)
	err := c.cc.Invoke(ctx, CerbosService_CheckResources_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cerbosServiceClient) ServerInfo(ctx context.Context, in *v1.ServerInfoRequest, opts ...grpc.CallOption) (*v11.ServerInfoResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v11.ServerInfoResponse)
	err := c.cc.Invoke(ctx, CerbosService_ServerInfo_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cerbosServiceClient) PlanResources(ctx context.Context, in *v1.PlanResourcesRequest, opts ...grpc.CallOption) (*v11.PlanResourcesResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v11.PlanResourcesResponse)
	err := c.cc.Invoke(ctx, CerbosService_PlanResources_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// CerbosServiceServer is the server API for CerbosService service.
// All implementations must embed UnimplementedCerbosServiceServer
// for forward compatibility.
type CerbosServiceServer interface {
	CheckResourceSet(context.Context, *v1.CheckResourceSetRequest) (*v11.CheckResourceSetResponse, error)
	CheckResourceBatch(context.Context, *v1.CheckResourceBatchRequest) (*v11.CheckResourceBatchResponse, error)
	CheckResources(context.Context, *v1.CheckResourcesRequest) (*v11.CheckResourcesResponse, error)
	ServerInfo(context.Context, *v1.ServerInfoRequest) (*v11.ServerInfoResponse, error)
	PlanResources(context.Context, *v1.PlanResourcesRequest) (*v11.PlanResourcesResponse, error)
	mustEmbedUnimplementedCerbosServiceServer()
}

// UnimplementedCerbosServiceServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedCerbosServiceServer struct{}

func (UnimplementedCerbosServiceServer) CheckResourceSet(context.Context, *v1.CheckResourceSetRequest) (*v11.CheckResourceSetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CheckResourceSet not implemented")
}
func (UnimplementedCerbosServiceServer) CheckResourceBatch(context.Context, *v1.CheckResourceBatchRequest) (*v11.CheckResourceBatchResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CheckResourceBatch not implemented")
}
func (UnimplementedCerbosServiceServer) CheckResources(context.Context, *v1.CheckResourcesRequest) (*v11.CheckResourcesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CheckResources not implemented")
}
func (UnimplementedCerbosServiceServer) ServerInfo(context.Context, *v1.ServerInfoRequest) (*v11.ServerInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ServerInfo not implemented")
}
func (UnimplementedCerbosServiceServer) PlanResources(context.Context, *v1.PlanResourcesRequest) (*v11.PlanResourcesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PlanResources not implemented")
}
func (UnimplementedCerbosServiceServer) mustEmbedUnimplementedCerbosServiceServer() {}
func (UnimplementedCerbosServiceServer) testEmbeddedByValue()                       {}

// UnsafeCerbosServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to CerbosServiceServer will
// result in compilation errors.
type UnsafeCerbosServiceServer interface {
	mustEmbedUnimplementedCerbosServiceServer()
}

func RegisterCerbosServiceServer(s grpc.ServiceRegistrar, srv CerbosServiceServer) {
	// If the following call pancis, it indicates UnimplementedCerbosServiceServer was
	// embedded by pointer and is nil.  This will cause panics if an
	// unimplemented method is ever invoked, so we test this at initialization
	// time to prevent it from happening at runtime later due to I/O.
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
		t.testEmbeddedByValue()
	}
	s.RegisterService(&CerbosService_ServiceDesc, srv)
}

func _CerbosService_CheckResourceSet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(v1.CheckResourceSetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CerbosServiceServer).CheckResourceSet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CerbosService_CheckResourceSet_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CerbosServiceServer).CheckResourceSet(ctx, req.(*v1.CheckResourceSetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CerbosService_CheckResourceBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(v1.CheckResourceBatchRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CerbosServiceServer).CheckResourceBatch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CerbosService_CheckResourceBatch_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CerbosServiceServer).CheckResourceBatch(ctx, req.(*v1.CheckResourceBatchRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CerbosService_CheckResources_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(v1.CheckResourcesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CerbosServiceServer).CheckResources(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CerbosService_CheckResources_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CerbosServiceServer).CheckResources(ctx, req.(*v1.CheckResourcesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CerbosService_ServerInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(v1.ServerInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CerbosServiceServer).ServerInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CerbosService_ServerInfo_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CerbosServiceServer).ServerInfo(ctx, req.(*v1.ServerInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CerbosService_PlanResources_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(v1.PlanResourcesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CerbosServiceServer).PlanResources(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CerbosService_PlanResources_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CerbosServiceServer).PlanResources(ctx, req.(*v1.PlanResourcesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// CerbosService_ServiceDesc is the grpc.ServiceDesc for CerbosService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var CerbosService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "cerbos.svc.v1.CerbosService",
	HandlerType: (*CerbosServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CheckResourceSet",
			Handler:    _CerbosService_CheckResourceSet_Handler,
		},
		{
			MethodName: "CheckResourceBatch",
			Handler:    _CerbosService_CheckResourceBatch_Handler,
		},
		{
			MethodName: "CheckResources",
			Handler:    _CerbosService_CheckResources_Handler,
		},
		{
			MethodName: "ServerInfo",
			Handler:    _CerbosService_ServerInfo_Handler,
		},
		{
			MethodName: "PlanResources",
			Handler:    _CerbosService_PlanResources_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "cerbos/svc/v1/svc.proto",
}

const (
	CerbosAdminService_AddOrUpdatePolicy_FullMethodName   = "/cerbos.svc.v1.CerbosAdminService/AddOrUpdatePolicy"
	CerbosAdminService_InspectPolicies_FullMethodName     = "/cerbos.svc.v1.CerbosAdminService/InspectPolicies"
	CerbosAdminService_ListPolicies_FullMethodName        = "/cerbos.svc.v1.CerbosAdminService/ListPolicies"
	CerbosAdminService_GetPolicy_FullMethodName           = "/cerbos.svc.v1.CerbosAdminService/GetPolicy"
	CerbosAdminService_DisablePolicy_FullMethodName       = "/cerbos.svc.v1.CerbosAdminService/DisablePolicy"
	CerbosAdminService_EnablePolicy_FullMethodName        = "/cerbos.svc.v1.CerbosAdminService/EnablePolicy"
	CerbosAdminService_ListAuditLogEntries_FullMethodName = "/cerbos.svc.v1.CerbosAdminService/ListAuditLogEntries"
	CerbosAdminService_AddOrUpdateSchema_FullMethodName   = "/cerbos.svc.v1.CerbosAdminService/AddOrUpdateSchema"
	CerbosAdminService_ListSchemas_FullMethodName         = "/cerbos.svc.v1.CerbosAdminService/ListSchemas"
	CerbosAdminService_GetSchema_FullMethodName           = "/cerbos.svc.v1.CerbosAdminService/GetSchema"
	CerbosAdminService_DeleteSchema_FullMethodName        = "/cerbos.svc.v1.CerbosAdminService/DeleteSchema"
	CerbosAdminService_ReloadStore_FullMethodName         = "/cerbos.svc.v1.CerbosAdminService/ReloadStore"
)

// CerbosAdminServiceClient is the client API for CerbosAdminService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type CerbosAdminServiceClient interface {
	AddOrUpdatePolicy(ctx context.Context, in *v1.AddOrUpdatePolicyRequest, opts ...grpc.CallOption) (*v11.AddOrUpdatePolicyResponse, error)
	InspectPolicies(ctx context.Context, in *v1.InspectPoliciesRequest, opts ...grpc.CallOption) (*v11.InspectPoliciesResponse, error)
	ListPolicies(ctx context.Context, in *v1.ListPoliciesRequest, opts ...grpc.CallOption) (*v11.ListPoliciesResponse, error)
	GetPolicy(ctx context.Context, in *v1.GetPolicyRequest, opts ...grpc.CallOption) (*v11.GetPolicyResponse, error)
	DisablePolicy(ctx context.Context, in *v1.DisablePolicyRequest, opts ...grpc.CallOption) (*v11.DisablePolicyResponse, error)
	EnablePolicy(ctx context.Context, in *v1.EnablePolicyRequest, opts ...grpc.CallOption) (*v11.EnablePolicyResponse, error)
	ListAuditLogEntries(ctx context.Context, in *v1.ListAuditLogEntriesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[v11.ListAuditLogEntriesResponse], error)
	AddOrUpdateSchema(ctx context.Context, in *v1.AddOrUpdateSchemaRequest, opts ...grpc.CallOption) (*v11.AddOrUpdateSchemaResponse, error)
	ListSchemas(ctx context.Context, in *v1.ListSchemasRequest, opts ...grpc.CallOption) (*v11.ListSchemasResponse, error)
	GetSchema(ctx context.Context, in *v1.GetSchemaRequest, opts ...grpc.CallOption) (*v11.GetSchemaResponse, error)
	DeleteSchema(ctx context.Context, in *v1.DeleteSchemaRequest, opts ...grpc.CallOption) (*v11.DeleteSchemaResponse, error)
	ReloadStore(ctx context.Context, in *v1.ReloadStoreRequest, opts ...grpc.CallOption) (*v11.ReloadStoreResponse, error)
}

type cerbosAdminServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewCerbosAdminServiceClient(cc grpc.ClientConnInterface) CerbosAdminServiceClient {
	return &cerbosAdminServiceClient{cc}
}

func (c *cerbosAdminServiceClient) AddOrUpdatePolicy(ctx context.Context, in *v1.AddOrUpdatePolicyRequest, opts ...grpc.CallOption) (*v11.AddOrUpdatePolicyResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v11.AddOrUpdatePolicyResponse)
	err := c.cc.Invoke(ctx, CerbosAdminService_AddOrUpdatePolicy_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cerbosAdminServiceClient) InspectPolicies(ctx context.Context, in *v1.InspectPoliciesRequest, opts ...grpc.CallOption) (*v11.InspectPoliciesResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v11.InspectPoliciesResponse)
	err := c.cc.Invoke(ctx, CerbosAdminService_InspectPolicies_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cerbosAdminServiceClient) ListPolicies(ctx context.Context, in *v1.ListPoliciesRequest, opts ...grpc.CallOption) (*v11.ListPoliciesResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v11.ListPoliciesResponse)
	err := c.cc.Invoke(ctx, CerbosAdminService_ListPolicies_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cerbosAdminServiceClient) GetPolicy(ctx context.Context, in *v1.GetPolicyRequest, opts ...grpc.CallOption) (*v11.GetPolicyResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v11.GetPolicyResponse)
	err := c.cc.Invoke(ctx, CerbosAdminService_GetPolicy_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cerbosAdminServiceClient) DisablePolicy(ctx context.Context, in *v1.DisablePolicyRequest, opts ...grpc.CallOption) (*v11.DisablePolicyResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v11.DisablePolicyResponse)
	err := c.cc.Invoke(ctx, CerbosAdminService_DisablePolicy_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cerbosAdminServiceClient) EnablePolicy(ctx context.Context, in *v1.EnablePolicyRequest, opts ...grpc.CallOption) (*v11.EnablePolicyResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v11.EnablePolicyResponse)
	err := c.cc.Invoke(ctx, CerbosAdminService_EnablePolicy_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cerbosAdminServiceClient) ListAuditLogEntries(ctx context.Context, in *v1.ListAuditLogEntriesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[v11.ListAuditLogEntriesResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &CerbosAdminService_ServiceDesc.Streams[0], CerbosAdminService_ListAuditLogEntries_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[v1.ListAuditLogEntriesRequest, v11.ListAuditLogEntriesResponse]{ClientStream: stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CerbosAdminService_ListAuditLogEntriesClient = grpc.ServerStreamingClient[v11.ListAuditLogEntriesResponse]

func (c *cerbosAdminServiceClient) AddOrUpdateSchema(ctx context.Context, in *v1.AddOrUpdateSchemaRequest, opts ...grpc.CallOption) (*v11.AddOrUpdateSchemaResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v11.AddOrUpdateSchemaResponse)
	err := c.cc.Invoke(ctx, CerbosAdminService_AddOrUpdateSchema_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cerbosAdminServiceClient) ListSchemas(ctx context.Context, in *v1.ListSchemasRequest, opts ...grpc.CallOption) (*v11.ListSchemasResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v11.ListSchemasResponse)
	err := c.cc.Invoke(ctx, CerbosAdminService_ListSchemas_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cerbosAdminServiceClient) GetSchema(ctx context.Context, in *v1.GetSchemaRequest, opts ...grpc.CallOption) (*v11.GetSchemaResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v11.GetSchemaResponse)
	err := c.cc.Invoke(ctx, CerbosAdminService_GetSchema_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cerbosAdminServiceClient) DeleteSchema(ctx context.Context, in *v1.DeleteSchemaRequest, opts ...grpc.CallOption) (*v11.DeleteSchemaResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v11.DeleteSchemaResponse)
	err := c.cc.Invoke(ctx, CerbosAdminService_DeleteSchema_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cerbosAdminServiceClient) ReloadStore(ctx context.Context, in *v1.ReloadStoreRequest, opts ...grpc.CallOption) (*v11.ReloadStoreResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v11.ReloadStoreResponse)
	err := c.cc.Invoke(ctx, CerbosAdminService_ReloadStore_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// CerbosAdminServiceServer is the server API for CerbosAdminService service.
// All implementations must embed UnimplementedCerbosAdminServiceServer
// for forward compatibility.
type CerbosAdminServiceServer interface {
	AddOrUpdatePolicy(context.Context, *v1.AddOrUpdatePolicyRequest) (*v11.AddOrUpdatePolicyResponse, error)
	InspectPolicies(context.Context, *v1.InspectPoliciesRequest) (*v11.InspectPoliciesResponse, error)
	ListPolicies(context.Context, *v1.ListPoliciesRequest) (*v11.ListPoliciesResponse, error)
	GetPolicy(context.Context, *v1.GetPolicyRequest) (*v11.GetPolicyResponse, error)
	DisablePolicy(context.Context, *v1.DisablePolicyRequest) (*v11.DisablePolicyResponse, error)
	EnablePolicy(context.Context, *v1.EnablePolicyRequest) (*v11.EnablePolicyResponse, error)
	ListAuditLogEntries(*v1.ListAuditLogEntriesRequest, grpc.ServerStreamingServer[v11.ListAuditLogEntriesResponse]) error
	AddOrUpdateSchema(context.Context, *v1.AddOrUpdateSchemaRequest) (*v11.AddOrUpdateSchemaResponse, error)
	ListSchemas(context.Context, *v1.ListSchemasRequest) (*v11.ListSchemasResponse, error)
	GetSchema(context.Context, *v1.GetSchemaRequest) (*v11.GetSchemaResponse, error)
	DeleteSchema(context.Context, *v1.DeleteSchemaRequest) (*v11.DeleteSchemaResponse, error)
	ReloadStore(context.Context, *v1.ReloadStoreRequest) (*v11.ReloadStoreResponse, error)
	mustEmbedUnimplementedCerbosAdminServiceServer()
}

// UnimplementedCerbosAdminServiceServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedCerbosAdminServiceServer struct{}

func (UnimplementedCerbosAdminServiceServer) AddOrUpdatePolicy(context.Context, *v1.AddOrUpdatePolicyRequest) (*v11.AddOrUpdatePolicyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddOrUpdatePolicy not implemented")
}
func (UnimplementedCerbosAdminServiceServer) InspectPolicies(context.Context, *v1.InspectPoliciesRequest) (*v11.InspectPoliciesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InspectPolicies not implemented")
}
func (UnimplementedCerbosAdminServiceServer) ListPolicies(context.Context, *v1.ListPoliciesRequest) (*v11.ListPoliciesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListPolicies not implemented")
}
func (UnimplementedCerbosAdminServiceServer) GetPolicy(context.Context, *v1.GetPolicyRequest) (*v11.GetPolicyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPolicy not implemented")
}
func (UnimplementedCerbosAdminServiceServer) DisablePolicy(context.Context, *v1.DisablePolicyRequest) (*v11.DisablePolicyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DisablePolicy not implemented")
}
func (UnimplementedCerbosAdminServiceServer) EnablePolicy(context.Context, *v1.EnablePolicyRequest) (*v11.EnablePolicyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EnablePolicy not implemented")
}
func (UnimplementedCerbosAdminServiceServer) ListAuditLogEntries(*v1.ListAuditLogEntriesRequest, grpc.ServerStreamingServer[v11.ListAuditLogEntriesResponse]) error {
	return status.Errorf(codes.Unimplemented, "method ListAuditLogEntries not implemented")
}
func (UnimplementedCerbosAdminServiceServer) AddOrUpdateSchema(context.Context, *v1.AddOrUpdateSchemaRequest) (*v11.AddOrUpdateSchemaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddOrUpdateSchema not implemented")
}
func (UnimplementedCerbosAdminServiceServer) ListSchemas(context.Context, *v1.ListSchemasRequest) (*v11.ListSchemasResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListSchemas not implemented")
}
func (UnimplementedCerbosAdminServiceServer) GetSchema(context.Context, *v1.GetSchemaRequest) (*v11.GetSchemaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSchema not implemented")
}
func (UnimplementedCerbosAdminServiceServer) DeleteSchema(context.Context, *v1.DeleteSchemaRequest) (*v11.DeleteSchemaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteSchema not implemented")
}
func (UnimplementedCerbosAdminServiceServer) ReloadStore(context.Context, *v1.ReloadStoreRequest) (*v11.ReloadStoreResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReloadStore not implemented")
}
func (UnimplementedCerbosAdminServiceServer) mustEmbedUnimplementedCerbosAdminServiceServer() {}
func (UnimplementedCerbosAdminServiceServer) testEmbeddedByValue()                            {}

// UnsafeCerbosAdminServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to CerbosAdminServiceServer will
// result in compilation errors.
type UnsafeCerbosAdminServiceServer interface {
	mustEmbedUnimplementedCerbosAdminServiceServer()
}

func RegisterCerbosAdminServiceServer(s grpc.ServiceRegistrar, srv CerbosAdminServiceServer) {
	// If the following call pancis, it indicates UnimplementedCerbosAdminServiceServer was
	// embedded by pointer and is nil.  This will cause panics if an
	// unimplemented method is ever invoked, so we test this at initialization
	// time to prevent it from happening at runtime later due to I/O.
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
		t.testEmbeddedByValue()
	}
	s.RegisterService(&CerbosAdminService_ServiceDesc, srv)
}

func _CerbosAdminService_AddOrUpdatePolicy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(v1.AddOrUpdatePolicyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CerbosAdminServiceServer).AddOrUpdatePolicy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CerbosAdminService_AddOrUpdatePolicy_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CerbosAdminServiceServer).AddOrUpdatePolicy(ctx, req.(*v1.AddOrUpdatePolicyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CerbosAdminService_InspectPolicies_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(v1.InspectPoliciesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CerbosAdminServiceServer).InspectPolicies(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CerbosAdminService_InspectPolicies_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CerbosAdminServiceServer).InspectPolicies(ctx, req.(*v1.InspectPoliciesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CerbosAdminService_ListPolicies_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(v1.ListPoliciesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CerbosAdminServiceServer).ListPolicies(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CerbosAdminService_ListPolicies_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CerbosAdminServiceServer).ListPolicies(ctx, req.(*v1.ListPoliciesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CerbosAdminService_GetPolicy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(v1.GetPolicyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CerbosAdminServiceServer).GetPolicy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CerbosAdminService_GetPolicy_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CerbosAdminServiceServer).GetPolicy(ctx, req.(*v1.GetPolicyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CerbosAdminService_DisablePolicy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(v1.DisablePolicyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CerbosAdminServiceServer).DisablePolicy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CerbosAdminService_DisablePolicy_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CerbosAdminServiceServer).DisablePolicy(ctx, req.(*v1.DisablePolicyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CerbosAdminService_EnablePolicy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(v1.EnablePolicyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CerbosAdminServiceServer).EnablePolicy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CerbosAdminService_EnablePolicy_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CerbosAdminServiceServer).EnablePolicy(ctx, req.(*v1.EnablePolicyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CerbosAdminService_ListAuditLogEntries_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(v1.ListAuditLogEntriesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(CerbosAdminServiceServer).ListAuditLogEntries(m, &grpc.GenericServerStream[v1.ListAuditLogEntriesRequest, v11.ListAuditLogEntriesResponse]{ServerStream: stream})
}

// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type CerbosAdminService_ListAuditLogEntriesServer = grpc.ServerStreamingServer[v11.ListAuditLogEntriesResponse]

func _CerbosAdminService_AddOrUpdateSchema_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(v1.AddOrUpdateSchemaRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CerbosAdminServiceServer).AddOrUpdateSchema(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CerbosAdminService_AddOrUpdateSchema_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CerbosAdminServiceServer).AddOrUpdateSchema(ctx, req.(*v1.AddOrUpdateSchemaRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CerbosAdminService_ListSchemas_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(v1.ListSchemasRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CerbosAdminServiceServer).ListSchemas(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CerbosAdminService_ListSchemas_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CerbosAdminServiceServer).ListSchemas(ctx, req.(*v1.ListSchemasRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CerbosAdminService_GetSchema_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(v1.GetSchemaRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CerbosAdminServiceServer).GetSchema(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CerbosAdminService_GetSchema_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CerbosAdminServiceServer).GetSchema(ctx, req.(*v1.GetSchemaRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CerbosAdminService_DeleteSchema_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(v1.DeleteSchemaRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CerbosAdminServiceServer).DeleteSchema(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CerbosAdminService_DeleteSchema_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CerbosAdminServiceServer).DeleteSchema(ctx, req.(*v1.DeleteSchemaRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CerbosAdminService_ReloadStore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(v1.ReloadStoreRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CerbosAdminServiceServer).ReloadStore(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CerbosAdminService_ReloadStore_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CerbosAdminServiceServer).ReloadStore(ctx, req.(*v1.ReloadStoreRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// CerbosAdminService_ServiceDesc is the grpc.ServiceDesc for CerbosAdminService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var CerbosAdminService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "cerbos.svc.v1.CerbosAdminService",
	HandlerType: (*CerbosAdminServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "AddOrUpdatePolicy",
			Handler:    _CerbosAdminService_AddOrUpdatePolicy_Handler,
		},
		{
			MethodName: "InspectPolicies",
			Handler:    _CerbosAdminService_InspectPolicies_Handler,
		},
		{
			MethodName: "ListPolicies",
			Handler:    _CerbosAdminService_ListPolicies_Handler,
		},
		{
			MethodName: "GetPolicy",
			Handler:    _CerbosAdminService_GetPolicy_Handler,
		},
		{
			MethodName: "DisablePolicy",
			Handler:    _CerbosAdminService_DisablePolicy_Handler,
		},
		{
			MethodName: "EnablePolicy",
			Handler:    _CerbosAdminService_EnablePolicy_Handler,
		},
		{
			MethodName: "AddOrUpdateSchema",
			Handler:    _CerbosAdminService_AddOrUpdateSchema_Handler,
		},
		{
			MethodName: "ListSchemas",
			Handler:    _CerbosAdminService_ListSchemas_Handler,
		},
		{
			MethodName: "GetSchema",
			Handler:    _CerbosAdminService_GetSchema_Handler,
		},
		{
			MethodName: "DeleteSchema",
			Handler:    _CerbosAdminService_DeleteSchema_Handler,
		},
		{
			MethodName: "ReloadStore",
			Handler:    _CerbosAdminService_ReloadStore_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ListAuditLogEntries",
			Handler:       _CerbosAdminService_ListAuditLogEntries_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "cerbos/svc/v1/svc.proto",
}

const (
	CerbosPlaygroundService_PlaygroundValidate_FullMethodName = "/cerbos.svc.v1.CerbosPlaygroundService/PlaygroundValidate"
	CerbosPlaygroundService_PlaygroundTest_FullMethodName     = "/cerbos.svc.v1.CerbosPlaygroundService/PlaygroundTest"
	CerbosPlaygroundService_PlaygroundEvaluate_FullMethodName = "/cerbos.svc.v1.CerbosPlaygroundService/PlaygroundEvaluate"
	CerbosPlaygroundService_PlaygroundProxy_FullMethodName    = "/cerbos.svc.v1.CerbosPlaygroundService/PlaygroundProxy"
)

// CerbosPlaygroundServiceClient is the client API for CerbosPlaygroundService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type CerbosPlaygroundServiceClient interface {
	PlaygroundValidate(ctx context.Context, in *v1.PlaygroundValidateRequest, opts ...grpc.CallOption) (*v11.PlaygroundValidateResponse, error)
	PlaygroundTest(ctx context.Context, in *v1.PlaygroundTestRequest, opts ...grpc.CallOption) (*v11.PlaygroundTestResponse, error)
	PlaygroundEvaluate(ctx context.Context, in *v1.PlaygroundEvaluateRequest, opts ...grpc.CallOption) (*v11.PlaygroundEvaluateResponse, error)
	PlaygroundProxy(ctx context.Context, in *v1.PlaygroundProxyRequest, opts ...grpc.CallOption) (*v11.PlaygroundProxyResponse, error)
}

type cerbosPlaygroundServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewCerbosPlaygroundServiceClient(cc grpc.ClientConnInterface) CerbosPlaygroundServiceClient {
	return &cerbosPlaygroundServiceClient{cc}
}

func (c *cerbosPlaygroundServiceClient) PlaygroundValidate(ctx context.Context, in *v1.PlaygroundValidateRequest, opts ...grpc.CallOption) (*v11.PlaygroundValidateResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v11.PlaygroundValidateResponse)
	err := c.cc.Invoke(ctx, CerbosPlaygroundService_PlaygroundValidate_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cerbosPlaygroundServiceClient) PlaygroundTest(ctx context.Context, in *v1.PlaygroundTestRequest, opts ...grpc.CallOption) (*v11.PlaygroundTestResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v11.PlaygroundTestResponse)
	err := c.cc.Invoke(ctx, CerbosPlaygroundService_PlaygroundTest_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cerbosPlaygroundServiceClient) PlaygroundEvaluate(ctx context.Context, in *v1.PlaygroundEvaluateRequest, opts ...grpc.CallOption) (*v11.PlaygroundEvaluateResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v11.PlaygroundEvaluateResponse)
	err := c.cc.Invoke(ctx, CerbosPlaygroundService_PlaygroundEvaluate_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cerbosPlaygroundServiceClient) PlaygroundProxy(ctx context.Context, in *v1.PlaygroundProxyRequest, opts ...grpc.CallOption) (*v11.PlaygroundProxyResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(v11.PlaygroundProxyResponse)
	err := c.cc.Invoke(ctx, CerbosPlaygroundService_PlaygroundProxy_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// CerbosPlaygroundServiceServer is the server API for CerbosPlaygroundService service.
// All implementations must embed UnimplementedCerbosPlaygroundServiceServer
// for forward compatibility.
type CerbosPlaygroundServiceServer interface {
	PlaygroundValidate(context.Context, *v1.PlaygroundValidateRequest) (*v11.PlaygroundValidateResponse, error)
	PlaygroundTest(context.Context, *v1.PlaygroundTestRequest) (*v11.PlaygroundTestResponse, error)
	PlaygroundEvaluate(context.Context, *v1.PlaygroundEvaluateRequest) (*v11.PlaygroundEvaluateResponse, error)
	PlaygroundProxy(context.Context, *v1.PlaygroundProxyRequest) (*v11.PlaygroundProxyResponse, error)
	mustEmbedUnimplementedCerbosPlaygroundServiceServer()
}

// UnimplementedCerbosPlaygroundServiceServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedCerbosPlaygroundServiceServer struct{}

func (UnimplementedCerbosPlaygroundServiceServer) PlaygroundValidate(context.Context, *v1.PlaygroundValidateRequest) (*v11.PlaygroundValidateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PlaygroundValidate not implemented")
}
func (UnimplementedCerbosPlaygroundServiceServer) PlaygroundTest(context.Context, *v1.PlaygroundTestRequest) (*v11.PlaygroundTestResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PlaygroundTest not implemented")
}
func (UnimplementedCerbosPlaygroundServiceServer) PlaygroundEvaluate(context.Context, *v1.PlaygroundEvaluateRequest) (*v11.PlaygroundEvaluateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PlaygroundEvaluate not implemented")
}
func (UnimplementedCerbosPlaygroundServiceServer) PlaygroundProxy(context.Context, *v1.PlaygroundProxyRequest) (*v11.PlaygroundProxyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PlaygroundProxy not implemented")
}
func (UnimplementedCerbosPlaygroundServiceServer) mustEmbedUnimplementedCerbosPlaygroundServiceServer() {
}
func (UnimplementedCerbosPlaygroundServiceServer) testEmbeddedByValue() {}

// UnsafeCerbosPlaygroundServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to CerbosPlaygroundServiceServer will
// result in compilation errors.
type UnsafeCerbosPlaygroundServiceServer interface {
	mustEmbedUnimplementedCerbosPlaygroundServiceServer()
}

func RegisterCerbosPlaygroundServiceServer(s grpc.ServiceRegistrar, srv CerbosPlaygroundServiceServer) {
	// If the following call pancis, it indicates UnimplementedCerbosPlaygroundServiceServer was
	// embedded by pointer and is nil.  This will cause panics if an
	// unimplemented method is ever invoked, so we test this at initialization
	// time to prevent it from happening at runtime later due to I/O.
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
		t.testEmbeddedByValue()
	}
	s.RegisterService(&CerbosPlaygroundService_ServiceDesc, srv)
}

func _CerbosPlaygroundService_PlaygroundValidate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(v1.PlaygroundValidateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CerbosPlaygroundServiceServer).PlaygroundValidate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CerbosPlaygroundService_PlaygroundValidate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CerbosPlaygroundServiceServer).PlaygroundValidate(ctx, req.(*v1.PlaygroundValidateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CerbosPlaygroundService_PlaygroundTest_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(v1.PlaygroundTestRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CerbosPlaygroundServiceServer).PlaygroundTest(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CerbosPlaygroundService_PlaygroundTest_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CerbosPlaygroundServiceServer).PlaygroundTest(ctx, req.(*v1.PlaygroundTestRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CerbosPlaygroundService_PlaygroundEvaluate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(v1.PlaygroundEvaluateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CerbosPlaygroundServiceServer).PlaygroundEvaluate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CerbosPlaygroundService_PlaygroundEvaluate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CerbosPlaygroundServiceServer).PlaygroundEvaluate(ctx, req.(*v1.PlaygroundEvaluateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CerbosPlaygroundService_PlaygroundProxy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(v1.PlaygroundProxyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CerbosPlaygroundServiceServer).PlaygroundProxy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CerbosPlaygroundService_PlaygroundProxy_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CerbosPlaygroundServiceServer).PlaygroundProxy(ctx, req.(*v1.PlaygroundProxyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// CerbosPlaygroundService_ServiceDesc is the grpc.ServiceDesc for CerbosPlaygroundService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var CerbosPlaygroundService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "cerbos.svc.v1.CerbosPlaygroundService",
	HandlerType: (*CerbosPlaygroundServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "PlaygroundValidate",
			Handler:    _CerbosPlaygroundService_PlaygroundValidate_Handler,
		},
		{
			MethodName: "PlaygroundTest",
			Handler:    _CerbosPlaygroundService_PlaygroundTest_Handler,
		},
		{
			MethodName: "PlaygroundEvaluate",
			Handler:    _CerbosPlaygroundService_PlaygroundEvaluate_Handler,
		},
		{
			MethodName: "PlaygroundProxy",
			Handler:    _CerbosPlaygroundService_PlaygroundProxy_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "cerbos/svc/v1/svc.proto",
}
