// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.5.1
// - protoc             v4.23.4
// source: adsys.proto

package adsys

import (
	context "context"
	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 (
	Service_Cat_FullMethodName                     = "/service/Cat"
	Service_Version_FullMethodName                 = "/service/Version"
	Service_Status_FullMethodName                  = "/service/Status"
	Service_Stop_FullMethodName                    = "/service/Stop"
	Service_UpdatePolicy_FullMethodName            = "/service/UpdatePolicy"
	Service_DumpPolicies_FullMethodName            = "/service/DumpPolicies"
	Service_DumpPoliciesDefinitions_FullMethodName = "/service/DumpPoliciesDefinitions"
	Service_GetDoc_FullMethodName                  = "/service/GetDoc"
	Service_ListDoc_FullMethodName                 = "/service/ListDoc"
	Service_ListUsers_FullMethodName               = "/service/ListUsers"
	Service_GPOListScript_FullMethodName           = "/service/GPOListScript"
	Service_CertAutoEnrollScript_FullMethodName    = "/service/CertAutoEnrollScript"
)

// ServiceClient is the client API for Service 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 ServiceClient interface {
	Cat(ctx context.Context, in *Empty, opts ...grpc.CallOption) (grpc.ServerStreamingClient[StringResponse], error)
	Version(ctx context.Context, in *Empty, opts ...grpc.CallOption) (grpc.ServerStreamingClient[StringResponse], error)
	Status(ctx context.Context, in *Empty, opts ...grpc.CallOption) (grpc.ServerStreamingClient[StringResponse], error)
	Stop(ctx context.Context, in *StopRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[Empty], error)
	UpdatePolicy(ctx context.Context, in *UpdatePolicyRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[Empty], error)
	DumpPolicies(ctx context.Context, in *DumpPoliciesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[StringResponse], error)
	DumpPoliciesDefinitions(ctx context.Context, in *DumpPolicyDefinitionsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[DumpPolicyDefinitionsResponse], error)
	GetDoc(ctx context.Context, in *GetDocRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[StringResponse], error)
	ListDoc(ctx context.Context, in *Empty, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListDocReponse], error)
	ListUsers(ctx context.Context, in *ListUsersRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[StringResponse], error)
	GPOListScript(ctx context.Context, in *Empty, opts ...grpc.CallOption) (grpc.ServerStreamingClient[StringResponse], error)
	CertAutoEnrollScript(ctx context.Context, in *Empty, opts ...grpc.CallOption) (grpc.ServerStreamingClient[StringResponse], error)
}

type serviceClient struct {
	cc grpc.ClientConnInterface
}

func NewServiceClient(cc grpc.ClientConnInterface) ServiceClient {
	return &serviceClient{cc}
}

func (c *serviceClient) Cat(ctx context.Context, in *Empty, opts ...grpc.CallOption) (grpc.ServerStreamingClient[StringResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &Service_ServiceDesc.Streams[0], Service_Cat_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[Empty, StringResponse]{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 Service_CatClient = grpc.ServerStreamingClient[StringResponse]

func (c *serviceClient) Version(ctx context.Context, in *Empty, opts ...grpc.CallOption) (grpc.ServerStreamingClient[StringResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &Service_ServiceDesc.Streams[1], Service_Version_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[Empty, StringResponse]{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 Service_VersionClient = grpc.ServerStreamingClient[StringResponse]

func (c *serviceClient) Status(ctx context.Context, in *Empty, opts ...grpc.CallOption) (grpc.ServerStreamingClient[StringResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &Service_ServiceDesc.Streams[2], Service_Status_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[Empty, StringResponse]{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 Service_StatusClient = grpc.ServerStreamingClient[StringResponse]

func (c *serviceClient) Stop(ctx context.Context, in *StopRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[Empty], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &Service_ServiceDesc.Streams[3], Service_Stop_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[StopRequest, Empty]{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 Service_StopClient = grpc.ServerStreamingClient[Empty]

func (c *serviceClient) UpdatePolicy(ctx context.Context, in *UpdatePolicyRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[Empty], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &Service_ServiceDesc.Streams[4], Service_UpdatePolicy_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[UpdatePolicyRequest, Empty]{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 Service_UpdatePolicyClient = grpc.ServerStreamingClient[Empty]

func (c *serviceClient) DumpPolicies(ctx context.Context, in *DumpPoliciesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[StringResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &Service_ServiceDesc.Streams[5], Service_DumpPolicies_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[DumpPoliciesRequest, StringResponse]{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 Service_DumpPoliciesClient = grpc.ServerStreamingClient[StringResponse]

func (c *serviceClient) DumpPoliciesDefinitions(ctx context.Context, in *DumpPolicyDefinitionsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[DumpPolicyDefinitionsResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &Service_ServiceDesc.Streams[6], Service_DumpPoliciesDefinitions_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[DumpPolicyDefinitionsRequest, DumpPolicyDefinitionsResponse]{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 Service_DumpPoliciesDefinitionsClient = grpc.ServerStreamingClient[DumpPolicyDefinitionsResponse]

func (c *serviceClient) GetDoc(ctx context.Context, in *GetDocRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[StringResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &Service_ServiceDesc.Streams[7], Service_GetDoc_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[GetDocRequest, StringResponse]{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 Service_GetDocClient = grpc.ServerStreamingClient[StringResponse]

func (c *serviceClient) ListDoc(ctx context.Context, in *Empty, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListDocReponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &Service_ServiceDesc.Streams[8], Service_ListDoc_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[Empty, ListDocReponse]{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 Service_ListDocClient = grpc.ServerStreamingClient[ListDocReponse]

func (c *serviceClient) ListUsers(ctx context.Context, in *ListUsersRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[StringResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &Service_ServiceDesc.Streams[9], Service_ListUsers_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[ListUsersRequest, StringResponse]{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 Service_ListUsersClient = grpc.ServerStreamingClient[StringResponse]

func (c *serviceClient) GPOListScript(ctx context.Context, in *Empty, opts ...grpc.CallOption) (grpc.ServerStreamingClient[StringResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &Service_ServiceDesc.Streams[10], Service_GPOListScript_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[Empty, StringResponse]{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 Service_GPOListScriptClient = grpc.ServerStreamingClient[StringResponse]

func (c *serviceClient) CertAutoEnrollScript(ctx context.Context, in *Empty, opts ...grpc.CallOption) (grpc.ServerStreamingClient[StringResponse], error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	stream, err := c.cc.NewStream(ctx, &Service_ServiceDesc.Streams[11], Service_CertAutoEnrollScript_FullMethodName, cOpts...)
	if err != nil {
		return nil, err
	}
	x := &grpc.GenericClientStream[Empty, StringResponse]{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 Service_CertAutoEnrollScriptClient = grpc.ServerStreamingClient[StringResponse]

// ServiceServer is the server API for Service service.
// All implementations must embed UnimplementedServiceServer
// for forward compatibility.
type ServiceServer interface {
	Cat(*Empty, grpc.ServerStreamingServer[StringResponse]) error
	Version(*Empty, grpc.ServerStreamingServer[StringResponse]) error
	Status(*Empty, grpc.ServerStreamingServer[StringResponse]) error
	Stop(*StopRequest, grpc.ServerStreamingServer[Empty]) error
	UpdatePolicy(*UpdatePolicyRequest, grpc.ServerStreamingServer[Empty]) error
	DumpPolicies(*DumpPoliciesRequest, grpc.ServerStreamingServer[StringResponse]) error
	DumpPoliciesDefinitions(*DumpPolicyDefinitionsRequest, grpc.ServerStreamingServer[DumpPolicyDefinitionsResponse]) error
	GetDoc(*GetDocRequest, grpc.ServerStreamingServer[StringResponse]) error
	ListDoc(*Empty, grpc.ServerStreamingServer[ListDocReponse]) error
	ListUsers(*ListUsersRequest, grpc.ServerStreamingServer[StringResponse]) error
	GPOListScript(*Empty, grpc.ServerStreamingServer[StringResponse]) error
	CertAutoEnrollScript(*Empty, grpc.ServerStreamingServer[StringResponse]) error
	mustEmbedUnimplementedServiceServer()
}

// UnimplementedServiceServer 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 UnimplementedServiceServer struct{}

func (UnimplementedServiceServer) Cat(*Empty, grpc.ServerStreamingServer[StringResponse]) error {
	return status.Errorf(codes.Unimplemented, "method Cat not implemented")
}
func (UnimplementedServiceServer) Version(*Empty, grpc.ServerStreamingServer[StringResponse]) error {
	return status.Errorf(codes.Unimplemented, "method Version not implemented")
}
func (UnimplementedServiceServer) Status(*Empty, grpc.ServerStreamingServer[StringResponse]) error {
	return status.Errorf(codes.Unimplemented, "method Status not implemented")
}
func (UnimplementedServiceServer) Stop(*StopRequest, grpc.ServerStreamingServer[Empty]) error {
	return status.Errorf(codes.Unimplemented, "method Stop not implemented")
}
func (UnimplementedServiceServer) UpdatePolicy(*UpdatePolicyRequest, grpc.ServerStreamingServer[Empty]) error {
	return status.Errorf(codes.Unimplemented, "method UpdatePolicy not implemented")
}
func (UnimplementedServiceServer) DumpPolicies(*DumpPoliciesRequest, grpc.ServerStreamingServer[StringResponse]) error {
	return status.Errorf(codes.Unimplemented, "method DumpPolicies not implemented")
}
func (UnimplementedServiceServer) DumpPoliciesDefinitions(*DumpPolicyDefinitionsRequest, grpc.ServerStreamingServer[DumpPolicyDefinitionsResponse]) error {
	return status.Errorf(codes.Unimplemented, "method DumpPoliciesDefinitions not implemented")
}
func (UnimplementedServiceServer) GetDoc(*GetDocRequest, grpc.ServerStreamingServer[StringResponse]) error {
	return status.Errorf(codes.Unimplemented, "method GetDoc not implemented")
}
func (UnimplementedServiceServer) ListDoc(*Empty, grpc.ServerStreamingServer[ListDocReponse]) error {
	return status.Errorf(codes.Unimplemented, "method ListDoc not implemented")
}
func (UnimplementedServiceServer) ListUsers(*ListUsersRequest, grpc.ServerStreamingServer[StringResponse]) error {
	return status.Errorf(codes.Unimplemented, "method ListUsers not implemented")
}
func (UnimplementedServiceServer) GPOListScript(*Empty, grpc.ServerStreamingServer[StringResponse]) error {
	return status.Errorf(codes.Unimplemented, "method GPOListScript not implemented")
}
func (UnimplementedServiceServer) CertAutoEnrollScript(*Empty, grpc.ServerStreamingServer[StringResponse]) error {
	return status.Errorf(codes.Unimplemented, "method CertAutoEnrollScript not implemented")
}
func (UnimplementedServiceServer) mustEmbedUnimplementedServiceServer() {}
func (UnimplementedServiceServer) testEmbeddedByValue()                 {}

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

func RegisterServiceServer(s grpc.ServiceRegistrar, srv ServiceServer) {
	// If the following call pancis, it indicates UnimplementedServiceServer 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(&Service_ServiceDesc, srv)
}

func _Service_Cat_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ServiceServer).Cat(m, &grpc.GenericServerStream[Empty, StringResponse]{ServerStream: stream})
}

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

func _Service_Version_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ServiceServer).Version(m, &grpc.GenericServerStream[Empty, StringResponse]{ServerStream: stream})
}

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

func _Service_Status_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ServiceServer).Status(m, &grpc.GenericServerStream[Empty, StringResponse]{ServerStream: stream})
}

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

func _Service_Stop_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(StopRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ServiceServer).Stop(m, &grpc.GenericServerStream[StopRequest, Empty]{ServerStream: stream})
}

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

func _Service_UpdatePolicy_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(UpdatePolicyRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ServiceServer).UpdatePolicy(m, &grpc.GenericServerStream[UpdatePolicyRequest, Empty]{ServerStream: stream})
}

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

func _Service_DumpPolicies_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(DumpPoliciesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ServiceServer).DumpPolicies(m, &grpc.GenericServerStream[DumpPoliciesRequest, StringResponse]{ServerStream: stream})
}

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

func _Service_DumpPoliciesDefinitions_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(DumpPolicyDefinitionsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ServiceServer).DumpPoliciesDefinitions(m, &grpc.GenericServerStream[DumpPolicyDefinitionsRequest, DumpPolicyDefinitionsResponse]{ServerStream: stream})
}

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

func _Service_GetDoc_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GetDocRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ServiceServer).GetDoc(m, &grpc.GenericServerStream[GetDocRequest, StringResponse]{ServerStream: stream})
}

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

func _Service_ListDoc_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ServiceServer).ListDoc(m, &grpc.GenericServerStream[Empty, ListDocReponse]{ServerStream: stream})
}

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

func _Service_ListUsers_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListUsersRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ServiceServer).ListUsers(m, &grpc.GenericServerStream[ListUsersRequest, StringResponse]{ServerStream: stream})
}

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

func _Service_GPOListScript_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ServiceServer).GPOListScript(m, &grpc.GenericServerStream[Empty, StringResponse]{ServerStream: stream})
}

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

func _Service_CertAutoEnrollScript_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ServiceServer).CertAutoEnrollScript(m, &grpc.GenericServerStream[Empty, StringResponse]{ServerStream: stream})
}

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

// Service_ServiceDesc is the grpc.ServiceDesc for Service service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Service_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "service",
	HandlerType: (*ServiceServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Cat",
			Handler:       _Service_Cat_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Version",
			Handler:       _Service_Version_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Status",
			Handler:       _Service_Status_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Stop",
			Handler:       _Service_Stop_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "UpdatePolicy",
			Handler:       _Service_UpdatePolicy_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DumpPolicies",
			Handler:       _Service_DumpPolicies_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DumpPoliciesDefinitions",
			Handler:       _Service_DumpPoliciesDefinitions_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetDoc",
			Handler:       _Service_GetDoc_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListDoc",
			Handler:       _Service_ListDoc_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListUsers",
			Handler:       _Service_ListUsers_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GPOListScript",
			Handler:       _Service_GPOListScript_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "CertAutoEnrollScript",
			Handler:       _Service_CertAutoEnrollScript_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "adsys.proto",
}
