# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
"""Client and server classes corresponding to protobuf-defined services."""
import grpc
import warnings

from neurion.sanctum import tx_pb2 as neurion_dot_sanctum_dot_tx__pb2

GRPC_GENERATED_VERSION = '1.70.0'
GRPC_VERSION = grpc.__version__
_version_not_supported = False

try:
    from grpc._utilities import first_version_is_lower
    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
except ImportError:
    _version_not_supported = True

if _version_not_supported:
    raise RuntimeError(
        f'The grpc package installed is at version {GRPC_VERSION},'
        + f' but the generated code in neurion/sanctum/tx_pb2_grpc.py depends on'
        + f' grpcio>={GRPC_GENERATED_VERSION}.'
        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
    )


class MsgStub(object):
    """Msg defines the Msg service.
    """

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.UpdateParams = channel.unary_unary(
                '/neurion.sanctum.Msg/UpdateParams',
                request_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgUpdateParams.SerializeToString,
                response_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgUpdateParamsResponse.FromString,
                _registered_method=True)
        self.SubmitDatasetApplication = channel.unary_unary(
                '/neurion.sanctum.Msg/SubmitDatasetApplication',
                request_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgSubmitDatasetApplication.SerializeToString,
                response_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgSubmitDatasetApplicationResponse.FromString,
                _registered_method=True)
        self.ApproveApplication = channel.unary_unary(
                '/neurion.sanctum.Msg/ApproveApplication',
                request_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgApproveApplication.SerializeToString,
                response_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgApproveApplicationResponse.FromString,
                _registered_method=True)
        self.RejectApplication = channel.unary_unary(
                '/neurion.sanctum.Msg/RejectApplication',
                request_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgRejectApplication.SerializeToString,
                response_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgRejectApplicationResponse.FromString,
                _registered_method=True)
        self.DisclaimDataset = channel.unary_unary(
                '/neurion.sanctum.Msg/DisclaimDataset',
                request_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgDisclaimDataset.SerializeToString,
                response_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgDisclaimDatasetResponse.FromString,
                _registered_method=True)
        self.RequestToUseDataset = channel.unary_unary(
                '/neurion.sanctum.Msg/RequestToUseDataset',
                request_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgRequestToUseDataset.SerializeToString,
                response_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgRequestToUseDatasetResponse.FromString,
                _registered_method=True)
        self.CancelDatasetUsageRequest = channel.unary_unary(
                '/neurion.sanctum.Msg/CancelDatasetUsageRequest',
                request_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgCancelDatasetUsageRequest.SerializeToString,
                response_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgCancelDatasetUsageRequestResponse.FromString,
                _registered_method=True)
        self.RejectDatasetUsageRequest = channel.unary_unary(
                '/neurion.sanctum.Msg/RejectDatasetUsageRequest',
                request_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgRejectDatasetUsageRequest.SerializeToString,
                response_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgRejectDatasetUsageRequestResponse.FromString,
                _registered_method=True)
        self.ApproveDatasetUsageRequest = channel.unary_unary(
                '/neurion.sanctum.Msg/ApproveDatasetUsageRequest',
                request_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgApproveDatasetUsageRequest.SerializeToString,
                response_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgApproveDatasetUsageRequestResponse.FromString,
                _registered_method=True)
        self.AddProcessor = channel.unary_unary(
                '/neurion.sanctum.Msg/AddProcessor',
                request_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgAddProcessor.SerializeToString,
                response_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgAddProcessorResponse.FromString,
                _registered_method=True)
        self.RemoveProcessor = channel.unary_unary(
                '/neurion.sanctum.Msg/RemoveProcessor',
                request_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgRemoveProcessor.SerializeToString,
                response_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgRemoveProcessorResponse.FromString,
                _registered_method=True)
        self.ProcessDatasetUsageRequest = channel.unary_unary(
                '/neurion.sanctum.Msg/ProcessDatasetUsageRequest',
                request_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgProcessDatasetUsageRequest.SerializeToString,
                response_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgProcessDatasetUsageRequestResponse.FromString,
                _registered_method=True)
        self.FinishDatasetUsageRequest = channel.unary_unary(
                '/neurion.sanctum.Msg/FinishDatasetUsageRequest',
                request_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgFinishDatasetUsageRequest.SerializeToString,
                response_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgFinishDatasetUsageRequestResponse.FromString,
                _registered_method=True)
        self.DisputeDatasetUsageRequest = channel.unary_unary(
                '/neurion.sanctum.Msg/DisputeDatasetUsageRequest',
                request_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgDisputeDatasetUsageRequest.SerializeToString,
                response_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgDisputeDatasetUsageRequestResponse.FromString,
                _registered_method=True)
        self.ApproveDispute = channel.unary_unary(
                '/neurion.sanctum.Msg/ApproveDispute',
                request_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgApproveDispute.SerializeToString,
                response_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgApproveDisputeResponse.FromString,
                _registered_method=True)
        self.RejectDispute = channel.unary_unary(
                '/neurion.sanctum.Msg/RejectDispute',
                request_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgRejectDispute.SerializeToString,
                response_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgRejectDisputeResponse.FromString,
                _registered_method=True)
        self.StakeToSanctum = channel.unary_unary(
                '/neurion.sanctum.Msg/StakeToSanctum',
                request_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgStakeToSanctum.SerializeToString,
                response_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgStakeToSanctumResponse.FromString,
                _registered_method=True)
        self.UnstakeFromSanctum = channel.unary_unary(
                '/neurion.sanctum.Msg/UnstakeFromSanctum',
                request_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgUnstakeFromSanctum.SerializeToString,
                response_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgUnstakeFromSanctumResponse.FromString,
                _registered_method=True)
        self.ClaimReward = channel.unary_unary(
                '/neurion.sanctum.Msg/ClaimReward',
                request_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgClaimReward.SerializeToString,
                response_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgClaimRewardResponse.FromString,
                _registered_method=True)


class MsgServicer(object):
    """Msg defines the Msg service.
    """

    def UpdateParams(self, request, context):
        """UpdateParams defines a (governance) operation for updating the module
        parameters. The authority defaults to the x/gov module account.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SubmitDatasetApplication(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ApproveApplication(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RejectApplication(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DisclaimDataset(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RequestToUseDataset(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CancelDatasetUsageRequest(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RejectDatasetUsageRequest(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ApproveDatasetUsageRequest(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def AddProcessor(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RemoveProcessor(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ProcessDatasetUsageRequest(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def FinishDatasetUsageRequest(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DisputeDatasetUsageRequest(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ApproveDispute(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RejectDispute(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StakeToSanctum(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def UnstakeFromSanctum(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ClaimReward(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_MsgServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'UpdateParams': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateParams,
                    request_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgUpdateParams.FromString,
                    response_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgUpdateParamsResponse.SerializeToString,
            ),
            'SubmitDatasetApplication': grpc.unary_unary_rpc_method_handler(
                    servicer.SubmitDatasetApplication,
                    request_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgSubmitDatasetApplication.FromString,
                    response_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgSubmitDatasetApplicationResponse.SerializeToString,
            ),
            'ApproveApplication': grpc.unary_unary_rpc_method_handler(
                    servicer.ApproveApplication,
                    request_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgApproveApplication.FromString,
                    response_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgApproveApplicationResponse.SerializeToString,
            ),
            'RejectApplication': grpc.unary_unary_rpc_method_handler(
                    servicer.RejectApplication,
                    request_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgRejectApplication.FromString,
                    response_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgRejectApplicationResponse.SerializeToString,
            ),
            'DisclaimDataset': grpc.unary_unary_rpc_method_handler(
                    servicer.DisclaimDataset,
                    request_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgDisclaimDataset.FromString,
                    response_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgDisclaimDatasetResponse.SerializeToString,
            ),
            'RequestToUseDataset': grpc.unary_unary_rpc_method_handler(
                    servicer.RequestToUseDataset,
                    request_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgRequestToUseDataset.FromString,
                    response_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgRequestToUseDatasetResponse.SerializeToString,
            ),
            'CancelDatasetUsageRequest': grpc.unary_unary_rpc_method_handler(
                    servicer.CancelDatasetUsageRequest,
                    request_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgCancelDatasetUsageRequest.FromString,
                    response_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgCancelDatasetUsageRequestResponse.SerializeToString,
            ),
            'RejectDatasetUsageRequest': grpc.unary_unary_rpc_method_handler(
                    servicer.RejectDatasetUsageRequest,
                    request_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgRejectDatasetUsageRequest.FromString,
                    response_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgRejectDatasetUsageRequestResponse.SerializeToString,
            ),
            'ApproveDatasetUsageRequest': grpc.unary_unary_rpc_method_handler(
                    servicer.ApproveDatasetUsageRequest,
                    request_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgApproveDatasetUsageRequest.FromString,
                    response_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgApproveDatasetUsageRequestResponse.SerializeToString,
            ),
            'AddProcessor': grpc.unary_unary_rpc_method_handler(
                    servicer.AddProcessor,
                    request_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgAddProcessor.FromString,
                    response_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgAddProcessorResponse.SerializeToString,
            ),
            'RemoveProcessor': grpc.unary_unary_rpc_method_handler(
                    servicer.RemoveProcessor,
                    request_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgRemoveProcessor.FromString,
                    response_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgRemoveProcessorResponse.SerializeToString,
            ),
            'ProcessDatasetUsageRequest': grpc.unary_unary_rpc_method_handler(
                    servicer.ProcessDatasetUsageRequest,
                    request_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgProcessDatasetUsageRequest.FromString,
                    response_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgProcessDatasetUsageRequestResponse.SerializeToString,
            ),
            'FinishDatasetUsageRequest': grpc.unary_unary_rpc_method_handler(
                    servicer.FinishDatasetUsageRequest,
                    request_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgFinishDatasetUsageRequest.FromString,
                    response_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgFinishDatasetUsageRequestResponse.SerializeToString,
            ),
            'DisputeDatasetUsageRequest': grpc.unary_unary_rpc_method_handler(
                    servicer.DisputeDatasetUsageRequest,
                    request_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgDisputeDatasetUsageRequest.FromString,
                    response_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgDisputeDatasetUsageRequestResponse.SerializeToString,
            ),
            'ApproveDispute': grpc.unary_unary_rpc_method_handler(
                    servicer.ApproveDispute,
                    request_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgApproveDispute.FromString,
                    response_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgApproveDisputeResponse.SerializeToString,
            ),
            'RejectDispute': grpc.unary_unary_rpc_method_handler(
                    servicer.RejectDispute,
                    request_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgRejectDispute.FromString,
                    response_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgRejectDisputeResponse.SerializeToString,
            ),
            'StakeToSanctum': grpc.unary_unary_rpc_method_handler(
                    servicer.StakeToSanctum,
                    request_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgStakeToSanctum.FromString,
                    response_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgStakeToSanctumResponse.SerializeToString,
            ),
            'UnstakeFromSanctum': grpc.unary_unary_rpc_method_handler(
                    servicer.UnstakeFromSanctum,
                    request_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgUnstakeFromSanctum.FromString,
                    response_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgUnstakeFromSanctumResponse.SerializeToString,
            ),
            'ClaimReward': grpc.unary_unary_rpc_method_handler(
                    servicer.ClaimReward,
                    request_deserializer=neurion_dot_sanctum_dot_tx__pb2.MsgClaimReward.FromString,
                    response_serializer=neurion_dot_sanctum_dot_tx__pb2.MsgClaimRewardResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'neurion.sanctum.Msg', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('neurion.sanctum.Msg', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class Msg(object):
    """Msg defines the Msg service.
    """

    @staticmethod
    def UpdateParams(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/neurion.sanctum.Msg/UpdateParams',
            neurion_dot_sanctum_dot_tx__pb2.MsgUpdateParams.SerializeToString,
            neurion_dot_sanctum_dot_tx__pb2.MsgUpdateParamsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SubmitDatasetApplication(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/neurion.sanctum.Msg/SubmitDatasetApplication',
            neurion_dot_sanctum_dot_tx__pb2.MsgSubmitDatasetApplication.SerializeToString,
            neurion_dot_sanctum_dot_tx__pb2.MsgSubmitDatasetApplicationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ApproveApplication(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/neurion.sanctum.Msg/ApproveApplication',
            neurion_dot_sanctum_dot_tx__pb2.MsgApproveApplication.SerializeToString,
            neurion_dot_sanctum_dot_tx__pb2.MsgApproveApplicationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RejectApplication(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/neurion.sanctum.Msg/RejectApplication',
            neurion_dot_sanctum_dot_tx__pb2.MsgRejectApplication.SerializeToString,
            neurion_dot_sanctum_dot_tx__pb2.MsgRejectApplicationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DisclaimDataset(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/neurion.sanctum.Msg/DisclaimDataset',
            neurion_dot_sanctum_dot_tx__pb2.MsgDisclaimDataset.SerializeToString,
            neurion_dot_sanctum_dot_tx__pb2.MsgDisclaimDatasetResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RequestToUseDataset(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/neurion.sanctum.Msg/RequestToUseDataset',
            neurion_dot_sanctum_dot_tx__pb2.MsgRequestToUseDataset.SerializeToString,
            neurion_dot_sanctum_dot_tx__pb2.MsgRequestToUseDatasetResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CancelDatasetUsageRequest(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/neurion.sanctum.Msg/CancelDatasetUsageRequest',
            neurion_dot_sanctum_dot_tx__pb2.MsgCancelDatasetUsageRequest.SerializeToString,
            neurion_dot_sanctum_dot_tx__pb2.MsgCancelDatasetUsageRequestResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RejectDatasetUsageRequest(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/neurion.sanctum.Msg/RejectDatasetUsageRequest',
            neurion_dot_sanctum_dot_tx__pb2.MsgRejectDatasetUsageRequest.SerializeToString,
            neurion_dot_sanctum_dot_tx__pb2.MsgRejectDatasetUsageRequestResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ApproveDatasetUsageRequest(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/neurion.sanctum.Msg/ApproveDatasetUsageRequest',
            neurion_dot_sanctum_dot_tx__pb2.MsgApproveDatasetUsageRequest.SerializeToString,
            neurion_dot_sanctum_dot_tx__pb2.MsgApproveDatasetUsageRequestResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def AddProcessor(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/neurion.sanctum.Msg/AddProcessor',
            neurion_dot_sanctum_dot_tx__pb2.MsgAddProcessor.SerializeToString,
            neurion_dot_sanctum_dot_tx__pb2.MsgAddProcessorResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RemoveProcessor(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/neurion.sanctum.Msg/RemoveProcessor',
            neurion_dot_sanctum_dot_tx__pb2.MsgRemoveProcessor.SerializeToString,
            neurion_dot_sanctum_dot_tx__pb2.MsgRemoveProcessorResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ProcessDatasetUsageRequest(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/neurion.sanctum.Msg/ProcessDatasetUsageRequest',
            neurion_dot_sanctum_dot_tx__pb2.MsgProcessDatasetUsageRequest.SerializeToString,
            neurion_dot_sanctum_dot_tx__pb2.MsgProcessDatasetUsageRequestResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def FinishDatasetUsageRequest(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/neurion.sanctum.Msg/FinishDatasetUsageRequest',
            neurion_dot_sanctum_dot_tx__pb2.MsgFinishDatasetUsageRequest.SerializeToString,
            neurion_dot_sanctum_dot_tx__pb2.MsgFinishDatasetUsageRequestResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DisputeDatasetUsageRequest(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/neurion.sanctum.Msg/DisputeDatasetUsageRequest',
            neurion_dot_sanctum_dot_tx__pb2.MsgDisputeDatasetUsageRequest.SerializeToString,
            neurion_dot_sanctum_dot_tx__pb2.MsgDisputeDatasetUsageRequestResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ApproveDispute(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/neurion.sanctum.Msg/ApproveDispute',
            neurion_dot_sanctum_dot_tx__pb2.MsgApproveDispute.SerializeToString,
            neurion_dot_sanctum_dot_tx__pb2.MsgApproveDisputeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RejectDispute(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/neurion.sanctum.Msg/RejectDispute',
            neurion_dot_sanctum_dot_tx__pb2.MsgRejectDispute.SerializeToString,
            neurion_dot_sanctum_dot_tx__pb2.MsgRejectDisputeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StakeToSanctum(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/neurion.sanctum.Msg/StakeToSanctum',
            neurion_dot_sanctum_dot_tx__pb2.MsgStakeToSanctum.SerializeToString,
            neurion_dot_sanctum_dot_tx__pb2.MsgStakeToSanctumResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UnstakeFromSanctum(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/neurion.sanctum.Msg/UnstakeFromSanctum',
            neurion_dot_sanctum_dot_tx__pb2.MsgUnstakeFromSanctum.SerializeToString,
            neurion_dot_sanctum_dot_tx__pb2.MsgUnstakeFromSanctumResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ClaimReward(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/neurion.sanctum.Msg/ClaimReward',
            neurion_dot_sanctum_dot_tx__pb2.MsgClaimReward.SerializeToString,
            neurion_dot_sanctum_dot_tx__pb2.MsgClaimRewardResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
