// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.6.1
// - protoc             v4.25.9
// source: admin/admin-account.proto

package pb

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 (
	AdminAccountService_AdminResetPassword_FullMethodName = "/admin.account.v1.AdminAccountService/AdminResetPassword"
	AdminAccountService_CreateUser_FullMethodName         = "/admin.account.v1.AdminAccountService/CreateUser"
	AdminAccountService_DeleteUser_FullMethodName         = "/admin.account.v1.AdminAccountService/DeleteUser"
	AdminAccountService_ChangeData_FullMethodName         = "/admin.account.v1.AdminAccountService/ChangeData"
	AdminAccountService_AssignRole_FullMethodName         = "/admin.account.v1.AdminAccountService/AssignRole"
	AdminAccountService_RevokeRole_FullMethodName         = "/admin.account.v1.AdminAccountService/RevokeRole"
	AdminAccountService_BlockUser_FullMethodName          = "/admin.account.v1.AdminAccountService/BlockUser"
	AdminAccountService_UnblockUser_FullMethodName        = "/admin.account.v1.AdminAccountService/UnblockUser"
	AdminAccountService_BlockIp_FullMethodName            = "/admin.account.v1.AdminAccountService/BlockIp"
	AdminAccountService_UnblockIp_FullMethodName          = "/admin.account.v1.AdminAccountService/UnblockIp"
	AdminAccountService_SyncUsersToSearch_FullMethodName  = "/admin.account.v1.AdminAccountService/SyncUsersToSearch"
)

// AdminAccountServiceClient is the client API for AdminAccountService 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 AdminAccountServiceClient interface {
	AdminResetPassword(ctx context.Context, in *AdminResetPasswordRequest, opts ...grpc.CallOption) (*AdminResetPasswordResponse, error)
	CreateUser(ctx context.Context, in *CreateUserRequest, opts ...grpc.CallOption) (*CreateUserResponse, error)
	DeleteUser(ctx context.Context, in *DeleteUserRequest, opts ...grpc.CallOption) (*DeleteUserResponse, error)
	ChangeData(ctx context.Context, in *ChangeDataRequest, opts ...grpc.CallOption) (*ChangeDataResponse, error)
	AssignRole(ctx context.Context, in *AssignRoleRequest, opts ...grpc.CallOption) (*AssignRoleResponse, error)
	RevokeRole(ctx context.Context, in *RevokeRoleRequest, opts ...grpc.CallOption) (*RevokeRoleResponse, error)
	BlockUser(ctx context.Context, in *BlockUserRequest, opts ...grpc.CallOption) (*BlockUserResponse, error)
	UnblockUser(ctx context.Context, in *UnblockUserRequest, opts ...grpc.CallOption) (*UnblockUserResponse, error)
	BlockIp(ctx context.Context, in *BlockIpRequest, opts ...grpc.CallOption) (*BlockIpResponse, error)
	UnblockIp(ctx context.Context, in *UnblockIpRequest, opts ...grpc.CallOption) (*UnblockIpResponse, error)
	SyncUsersToSearch(ctx context.Context, in *SyncUsersToSearchRequest, opts ...grpc.CallOption) (*SyncUsersToSearchResponse, error)
}

type adminAccountServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewAdminAccountServiceClient(cc grpc.ClientConnInterface) AdminAccountServiceClient {
	return &adminAccountServiceClient{cc}
}

func (c *adminAccountServiceClient) AdminResetPassword(ctx context.Context, in *AdminResetPasswordRequest, opts ...grpc.CallOption) (*AdminResetPasswordResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(AdminResetPasswordResponse)
	err := c.cc.Invoke(ctx, AdminAccountService_AdminResetPassword_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminAccountServiceClient) CreateUser(ctx context.Context, in *CreateUserRequest, opts ...grpc.CallOption) (*CreateUserResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreateUserResponse)
	err := c.cc.Invoke(ctx, AdminAccountService_CreateUser_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminAccountServiceClient) DeleteUser(ctx context.Context, in *DeleteUserRequest, opts ...grpc.CallOption) (*DeleteUserResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeleteUserResponse)
	err := c.cc.Invoke(ctx, AdminAccountService_DeleteUser_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminAccountServiceClient) ChangeData(ctx context.Context, in *ChangeDataRequest, opts ...grpc.CallOption) (*ChangeDataResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ChangeDataResponse)
	err := c.cc.Invoke(ctx, AdminAccountService_ChangeData_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminAccountServiceClient) AssignRole(ctx context.Context, in *AssignRoleRequest, opts ...grpc.CallOption) (*AssignRoleResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(AssignRoleResponse)
	err := c.cc.Invoke(ctx, AdminAccountService_AssignRole_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminAccountServiceClient) RevokeRole(ctx context.Context, in *RevokeRoleRequest, opts ...grpc.CallOption) (*RevokeRoleResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RevokeRoleResponse)
	err := c.cc.Invoke(ctx, AdminAccountService_RevokeRole_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminAccountServiceClient) BlockUser(ctx context.Context, in *BlockUserRequest, opts ...grpc.CallOption) (*BlockUserResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(BlockUserResponse)
	err := c.cc.Invoke(ctx, AdminAccountService_BlockUser_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminAccountServiceClient) UnblockUser(ctx context.Context, in *UnblockUserRequest, opts ...grpc.CallOption) (*UnblockUserResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UnblockUserResponse)
	err := c.cc.Invoke(ctx, AdminAccountService_UnblockUser_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminAccountServiceClient) BlockIp(ctx context.Context, in *BlockIpRequest, opts ...grpc.CallOption) (*BlockIpResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(BlockIpResponse)
	err := c.cc.Invoke(ctx, AdminAccountService_BlockIp_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminAccountServiceClient) UnblockIp(ctx context.Context, in *UnblockIpRequest, opts ...grpc.CallOption) (*UnblockIpResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UnblockIpResponse)
	err := c.cc.Invoke(ctx, AdminAccountService_UnblockIp_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminAccountServiceClient) SyncUsersToSearch(ctx context.Context, in *SyncUsersToSearchRequest, opts ...grpc.CallOption) (*SyncUsersToSearchResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SyncUsersToSearchResponse)
	err := c.cc.Invoke(ctx, AdminAccountService_SyncUsersToSearch_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AdminAccountServiceServer is the server API for AdminAccountService service.
// All implementations must embed UnimplementedAdminAccountServiceServer
// for forward compatibility.
type AdminAccountServiceServer interface {
	AdminResetPassword(context.Context, *AdminResetPasswordRequest) (*AdminResetPasswordResponse, error)
	CreateUser(context.Context, *CreateUserRequest) (*CreateUserResponse, error)
	DeleteUser(context.Context, *DeleteUserRequest) (*DeleteUserResponse, error)
	ChangeData(context.Context, *ChangeDataRequest) (*ChangeDataResponse, error)
	AssignRole(context.Context, *AssignRoleRequest) (*AssignRoleResponse, error)
	RevokeRole(context.Context, *RevokeRoleRequest) (*RevokeRoleResponse, error)
	BlockUser(context.Context, *BlockUserRequest) (*BlockUserResponse, error)
	UnblockUser(context.Context, *UnblockUserRequest) (*UnblockUserResponse, error)
	BlockIp(context.Context, *BlockIpRequest) (*BlockIpResponse, error)
	UnblockIp(context.Context, *UnblockIpRequest) (*UnblockIpResponse, error)
	SyncUsersToSearch(context.Context, *SyncUsersToSearchRequest) (*SyncUsersToSearchResponse, error)
	mustEmbedUnimplementedAdminAccountServiceServer()
}

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

func (UnimplementedAdminAccountServiceServer) AdminResetPassword(context.Context, *AdminResetPasswordRequest) (*AdminResetPasswordResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method AdminResetPassword not implemented")
}
func (UnimplementedAdminAccountServiceServer) CreateUser(context.Context, *CreateUserRequest) (*CreateUserResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method CreateUser not implemented")
}
func (UnimplementedAdminAccountServiceServer) DeleteUser(context.Context, *DeleteUserRequest) (*DeleteUserResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method DeleteUser not implemented")
}
func (UnimplementedAdminAccountServiceServer) ChangeData(context.Context, *ChangeDataRequest) (*ChangeDataResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ChangeData not implemented")
}
func (UnimplementedAdminAccountServiceServer) AssignRole(context.Context, *AssignRoleRequest) (*AssignRoleResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method AssignRole not implemented")
}
func (UnimplementedAdminAccountServiceServer) RevokeRole(context.Context, *RevokeRoleRequest) (*RevokeRoleResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method RevokeRole not implemented")
}
func (UnimplementedAdminAccountServiceServer) BlockUser(context.Context, *BlockUserRequest) (*BlockUserResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method BlockUser not implemented")
}
func (UnimplementedAdminAccountServiceServer) UnblockUser(context.Context, *UnblockUserRequest) (*UnblockUserResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method UnblockUser not implemented")
}
func (UnimplementedAdminAccountServiceServer) BlockIp(context.Context, *BlockIpRequest) (*BlockIpResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method BlockIp not implemented")
}
func (UnimplementedAdminAccountServiceServer) UnblockIp(context.Context, *UnblockIpRequest) (*UnblockIpResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method UnblockIp not implemented")
}
func (UnimplementedAdminAccountServiceServer) SyncUsersToSearch(context.Context, *SyncUsersToSearchRequest) (*SyncUsersToSearchResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method SyncUsersToSearch not implemented")
}
func (UnimplementedAdminAccountServiceServer) mustEmbedUnimplementedAdminAccountServiceServer() {}
func (UnimplementedAdminAccountServiceServer) testEmbeddedByValue()                             {}

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

func RegisterAdminAccountServiceServer(s grpc.ServiceRegistrar, srv AdminAccountServiceServer) {
	// If the following call panics, it indicates UnimplementedAdminAccountServiceServer 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(&AdminAccountService_ServiceDesc, srv)
}

func _AdminAccountService_AdminResetPassword_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AdminResetPasswordRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminAccountServiceServer).AdminResetPassword(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminAccountService_AdminResetPassword_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminAccountServiceServer).AdminResetPassword(ctx, req.(*AdminResetPasswordRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminAccountService_CreateUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateUserRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminAccountServiceServer).CreateUser(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminAccountService_CreateUser_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminAccountServiceServer).CreateUser(ctx, req.(*CreateUserRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminAccountService_DeleteUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteUserRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminAccountServiceServer).DeleteUser(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminAccountService_DeleteUser_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminAccountServiceServer).DeleteUser(ctx, req.(*DeleteUserRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminAccountService_ChangeData_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ChangeDataRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminAccountServiceServer).ChangeData(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminAccountService_ChangeData_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminAccountServiceServer).ChangeData(ctx, req.(*ChangeDataRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminAccountService_AssignRole_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AssignRoleRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminAccountServiceServer).AssignRole(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminAccountService_AssignRole_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminAccountServiceServer).AssignRole(ctx, req.(*AssignRoleRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminAccountService_RevokeRole_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RevokeRoleRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminAccountServiceServer).RevokeRole(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminAccountService_RevokeRole_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminAccountServiceServer).RevokeRole(ctx, req.(*RevokeRoleRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminAccountService_BlockUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BlockUserRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminAccountServiceServer).BlockUser(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminAccountService_BlockUser_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminAccountServiceServer).BlockUser(ctx, req.(*BlockUserRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminAccountService_UnblockUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UnblockUserRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminAccountServiceServer).UnblockUser(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminAccountService_UnblockUser_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminAccountServiceServer).UnblockUser(ctx, req.(*UnblockUserRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminAccountService_BlockIp_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BlockIpRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminAccountServiceServer).BlockIp(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminAccountService_BlockIp_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminAccountServiceServer).BlockIp(ctx, req.(*BlockIpRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminAccountService_UnblockIp_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UnblockIpRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminAccountServiceServer).UnblockIp(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminAccountService_UnblockIp_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminAccountServiceServer).UnblockIp(ctx, req.(*UnblockIpRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminAccountService_SyncUsersToSearch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SyncUsersToSearchRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminAccountServiceServer).SyncUsersToSearch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminAccountService_SyncUsersToSearch_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminAccountServiceServer).SyncUsersToSearch(ctx, req.(*SyncUsersToSearchRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// AdminAccountService_ServiceDesc is the grpc.ServiceDesc for AdminAccountService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AdminAccountService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "admin.account.v1.AdminAccountService",
	HandlerType: (*AdminAccountServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "AdminResetPassword",
			Handler:    _AdminAccountService_AdminResetPassword_Handler,
		},
		{
			MethodName: "CreateUser",
			Handler:    _AdminAccountService_CreateUser_Handler,
		},
		{
			MethodName: "DeleteUser",
			Handler:    _AdminAccountService_DeleteUser_Handler,
		},
		{
			MethodName: "ChangeData",
			Handler:    _AdminAccountService_ChangeData_Handler,
		},
		{
			MethodName: "AssignRole",
			Handler:    _AdminAccountService_AssignRole_Handler,
		},
		{
			MethodName: "RevokeRole",
			Handler:    _AdminAccountService_RevokeRole_Handler,
		},
		{
			MethodName: "BlockUser",
			Handler:    _AdminAccountService_BlockUser_Handler,
		},
		{
			MethodName: "UnblockUser",
			Handler:    _AdminAccountService_UnblockUser_Handler,
		},
		{
			MethodName: "BlockIp",
			Handler:    _AdminAccountService_BlockIp_Handler,
		},
		{
			MethodName: "UnblockIp",
			Handler:    _AdminAccountService_UnblockIp_Handler,
		},
		{
			MethodName: "SyncUsersToSearch",
			Handler:    _AdminAccountService_SyncUsersToSearch_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "admin/admin-account.proto",
}