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

import qiclib.packages.grpc.datatypes_pb2 as datatypes__pb2
import qiclib.packages.grpc.recording_pb2 as recording__pb2

GRPC_GENERATED_VERSION = '1.66.1'
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 recording_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 RecordingStub(object):
    """Missing associated documentation comment in .proto file."""

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

        Args:
            channel: A grpc.Channel.
        """
        self.Reset = channel.unary_unary(
                '/recording.Recording/Reset',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.ReportStatus = channel.unary_unary(
                '/recording.Recording/ReportStatus',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=recording__pb2.StatusReport.FromString,
                _registered_method=True)
        self.ResetStatus = channel.unary_unary(
                '/recording.Recording/ResetStatus',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.ResetStatusAll = channel.unary_unary(
                '/recording.Recording/ResetStatusAll',
                request_serializer=datatypes__pb2.Empty.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.IsInterferometerMode = channel.unary_unary(
                '/recording.Recording/IsInterferometerMode',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=recording__pb2.InterferometerMode.FromString,
                _registered_method=True)
        self.SetInterferometerMode = channel.unary_unary(
                '/recording.Recording/SetInterferometerMode',
                request_serializer=recording__pb2.InterferometerMode.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.IsContinuousMode = channel.unary_unary(
                '/recording.Recording/IsContinuousMode',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=recording__pb2.ContinuousMode.FromString,
                _registered_method=True)
        self.SetContinuousMode = channel.unary_unary(
                '/recording.Recording/SetContinuousMode',
                request_serializer=recording__pb2.ContinuousMode.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetLastTrigger = channel.unary_unary(
                '/recording.Recording/GetLastTrigger',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=recording__pb2.Trigger.FromString,
                _registered_method=True)
        self.TriggerManually = channel.unary_unary(
                '/recording.Recording/TriggerManually',
                request_serializer=recording__pb2.Trigger.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetTriggerOffset = channel.unary_unary(
                '/recording.Recording/GetTriggerOffset',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=recording__pb2.TriggerOffset.FromString,
                _registered_method=True)
        self.SetTriggerOffset = channel.unary_unary(
                '/recording.Recording/SetTriggerOffset',
                request_serializer=recording__pb2.TriggerOffset.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetRecordingDuration = channel.unary_unary(
                '/recording.Recording/GetRecordingDuration',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=recording__pb2.RecordingDuration.FromString,
                _registered_method=True)
        self.SetRecordingDuration = channel.unary_unary(
                '/recording.Recording/SetRecordingDuration',
                request_serializer=recording__pb2.RecordingDuration.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetValueShift = channel.unary_unary(
                '/recording.Recording/GetValueShift',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=recording__pb2.ValueShift.FromString,
                _registered_method=True)
        self.SetValueShift = channel.unary_unary(
                '/recording.Recording/SetValueShift',
                request_serializer=recording__pb2.ValueShift.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetExpectedHighestSignalAmplitude = channel.unary_unary(
                '/recording.Recording/GetExpectedHighestSignalAmplitude',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=datatypes__pb2.Int.FromString,
                _registered_method=True)
        self.SetExpectedHighestSignalAmplitude = channel.unary_unary(
                '/recording.Recording/SetExpectedHighestSignalAmplitude',
                request_serializer=datatypes__pb2.IndexedInt.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetAverageShift = channel.unary_unary(
                '/recording.Recording/GetAverageShift',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=recording__pb2.AverageShift.FromString,
                _registered_method=True)
        self.SetAverageShift = channel.unary_unary(
                '/recording.Recording/SetAverageShift',
                request_serializer=recording__pb2.AverageShift.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetConditioningMatrix = channel.unary_unary(
                '/recording.Recording/GetConditioningMatrix',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=recording__pb2.ConditioningMatrix.FromString,
                _registered_method=True)
        self.SetConditioningMatrix = channel.unary_unary(
                '/recording.Recording/SetConditioningMatrix',
                request_serializer=recording__pb2.ConditioningMatrix.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetConditioningOffset = channel.unary_unary(
                '/recording.Recording/GetConditioningOffset',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=recording__pb2.ConditioningOffset.FromString,
                _registered_method=True)
        self.SetConditioningOffset = channel.unary_unary(
                '/recording.Recording/SetConditioningOffset',
                request_serializer=recording__pb2.ConditioningOffset.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetInternalFrequency = channel.unary_unary(
                '/recording.Recording/GetInternalFrequency',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=recording__pb2.Frequency.FromString,
                _registered_method=True)
        self.SetInternalFrequency = channel.unary_unary(
                '/recording.Recording/SetInternalFrequency',
                request_serializer=recording__pb2.Frequency.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetInternalPhaseOffset = channel.unary_unary(
                '/recording.Recording/GetInternalPhaseOffset',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=recording__pb2.PhaseOffset.FromString,
                _registered_method=True)
        self.SetInternalPhaseOffset = channel.unary_unary(
                '/recording.Recording/SetInternalPhaseOffset',
                request_serializer=recording__pb2.PhaseOffset.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetReferenceFrequency = channel.unary_unary(
                '/recording.Recording/GetReferenceFrequency',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=recording__pb2.Frequency.FromString,
                _registered_method=True)
        self.SetReferenceFrequency = channel.unary_unary(
                '/recording.Recording/SetReferenceFrequency',
                request_serializer=recording__pb2.Frequency.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetReferenceDelay = channel.unary_unary(
                '/recording.Recording/GetReferenceDelay',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=recording__pb2.ReferenceDelay.FromString,
                _registered_method=True)
        self.SetReferenceDelay = channel.unary_unary(
                '/recording.Recording/SetReferenceDelay',
                request_serializer=recording__pb2.ReferenceDelay.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetStateConfig = channel.unary_unary(
                '/recording.Recording/GetStateConfig',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=recording__pb2.StateConfig.FromString,
                _registered_method=True)
        self.SetStateConfig = channel.unary_unary(
                '/recording.Recording/SetStateConfig',
                request_serializer=recording__pb2.StateConfig.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetAveragedResult = channel.unary_unary(
                '/recording.Recording/GetAveragedResult',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=recording__pb2.IQResult.FromString,
                _registered_method=True)
        self.GetSingleResult = channel.unary_unary(
                '/recording.Recording/GetSingleResult',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=recording__pb2.IQResult.FromString,
                _registered_method=True)
        self.GetResultMemoryStatus = channel.unary_unary(
                '/recording.Recording/GetResultMemoryStatus',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=recording__pb2.MemoryStatus.FromString,
                _registered_method=True)
        self.GetResultMemorySize = channel.unary_unary(
                '/recording.Recording/GetResultMemorySize',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=recording__pb2.MemorySize.FromString,
                _registered_method=True)
        self.GetResultMemory = channel.unary_unary(
                '/recording.Recording/GetResultMemory',
                request_serializer=recording__pb2.MemorySize.SerializeToString,
                response_deserializer=recording__pb2.ResultMemory.FromString,
                _registered_method=True)
        self.GetRawMemory = channel.unary_unary(
                '/recording.Recording/GetRawMemory',
                request_serializer=recording__pb2.MemorySize.SerializeToString,
                response_deserializer=recording__pb2.RawMemory.FromString,
                _registered_method=True)


class RecordingServicer(object):
    """Missing associated documentation comment in .proto file."""

    def Reset(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 ReportStatus(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 ResetStatus(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 ResetStatusAll(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 IsInterferometerMode(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 SetInterferometerMode(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 IsContinuousMode(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 SetContinuousMode(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 GetLastTrigger(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 TriggerManually(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 GetTriggerOffset(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 SetTriggerOffset(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 GetRecordingDuration(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 SetRecordingDuration(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 GetValueShift(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 SetValueShift(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 GetExpectedHighestSignalAmplitude(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 SetExpectedHighestSignalAmplitude(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 GetAverageShift(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 SetAverageShift(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 GetConditioningMatrix(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 SetConditioningMatrix(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 GetConditioningOffset(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 SetConditioningOffset(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 GetInternalFrequency(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 SetInternalFrequency(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 GetInternalPhaseOffset(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 SetInternalPhaseOffset(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 GetReferenceFrequency(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 SetReferenceFrequency(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 GetReferenceDelay(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 SetReferenceDelay(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 GetStateConfig(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 SetStateConfig(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 GetAveragedResult(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 GetSingleResult(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 GetResultMemoryStatus(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 GetResultMemorySize(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 GetResultMemory(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 GetRawMemory(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_RecordingServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Reset': grpc.unary_unary_rpc_method_handler(
                    servicer.Reset,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'ReportStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.ReportStatus,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=recording__pb2.StatusReport.SerializeToString,
            ),
            'ResetStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.ResetStatus,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'ResetStatusAll': grpc.unary_unary_rpc_method_handler(
                    servicer.ResetStatusAll,
                    request_deserializer=datatypes__pb2.Empty.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'IsInterferometerMode': grpc.unary_unary_rpc_method_handler(
                    servicer.IsInterferometerMode,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=recording__pb2.InterferometerMode.SerializeToString,
            ),
            'SetInterferometerMode': grpc.unary_unary_rpc_method_handler(
                    servicer.SetInterferometerMode,
                    request_deserializer=recording__pb2.InterferometerMode.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'IsContinuousMode': grpc.unary_unary_rpc_method_handler(
                    servicer.IsContinuousMode,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=recording__pb2.ContinuousMode.SerializeToString,
            ),
            'SetContinuousMode': grpc.unary_unary_rpc_method_handler(
                    servicer.SetContinuousMode,
                    request_deserializer=recording__pb2.ContinuousMode.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetLastTrigger': grpc.unary_unary_rpc_method_handler(
                    servicer.GetLastTrigger,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=recording__pb2.Trigger.SerializeToString,
            ),
            'TriggerManually': grpc.unary_unary_rpc_method_handler(
                    servicer.TriggerManually,
                    request_deserializer=recording__pb2.Trigger.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetTriggerOffset': grpc.unary_unary_rpc_method_handler(
                    servicer.GetTriggerOffset,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=recording__pb2.TriggerOffset.SerializeToString,
            ),
            'SetTriggerOffset': grpc.unary_unary_rpc_method_handler(
                    servicer.SetTriggerOffset,
                    request_deserializer=recording__pb2.TriggerOffset.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetRecordingDuration': grpc.unary_unary_rpc_method_handler(
                    servicer.GetRecordingDuration,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=recording__pb2.RecordingDuration.SerializeToString,
            ),
            'SetRecordingDuration': grpc.unary_unary_rpc_method_handler(
                    servicer.SetRecordingDuration,
                    request_deserializer=recording__pb2.RecordingDuration.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetValueShift': grpc.unary_unary_rpc_method_handler(
                    servicer.GetValueShift,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=recording__pb2.ValueShift.SerializeToString,
            ),
            'SetValueShift': grpc.unary_unary_rpc_method_handler(
                    servicer.SetValueShift,
                    request_deserializer=recording__pb2.ValueShift.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetExpectedHighestSignalAmplitude': grpc.unary_unary_rpc_method_handler(
                    servicer.GetExpectedHighestSignalAmplitude,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=datatypes__pb2.Int.SerializeToString,
            ),
            'SetExpectedHighestSignalAmplitude': grpc.unary_unary_rpc_method_handler(
                    servicer.SetExpectedHighestSignalAmplitude,
                    request_deserializer=datatypes__pb2.IndexedInt.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetAverageShift': grpc.unary_unary_rpc_method_handler(
                    servicer.GetAverageShift,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=recording__pb2.AverageShift.SerializeToString,
            ),
            'SetAverageShift': grpc.unary_unary_rpc_method_handler(
                    servicer.SetAverageShift,
                    request_deserializer=recording__pb2.AverageShift.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetConditioningMatrix': grpc.unary_unary_rpc_method_handler(
                    servicer.GetConditioningMatrix,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=recording__pb2.ConditioningMatrix.SerializeToString,
            ),
            'SetConditioningMatrix': grpc.unary_unary_rpc_method_handler(
                    servicer.SetConditioningMatrix,
                    request_deserializer=recording__pb2.ConditioningMatrix.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetConditioningOffset': grpc.unary_unary_rpc_method_handler(
                    servicer.GetConditioningOffset,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=recording__pb2.ConditioningOffset.SerializeToString,
            ),
            'SetConditioningOffset': grpc.unary_unary_rpc_method_handler(
                    servicer.SetConditioningOffset,
                    request_deserializer=recording__pb2.ConditioningOffset.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetInternalFrequency': grpc.unary_unary_rpc_method_handler(
                    servicer.GetInternalFrequency,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=recording__pb2.Frequency.SerializeToString,
            ),
            'SetInternalFrequency': grpc.unary_unary_rpc_method_handler(
                    servicer.SetInternalFrequency,
                    request_deserializer=recording__pb2.Frequency.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetInternalPhaseOffset': grpc.unary_unary_rpc_method_handler(
                    servicer.GetInternalPhaseOffset,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=recording__pb2.PhaseOffset.SerializeToString,
            ),
            'SetInternalPhaseOffset': grpc.unary_unary_rpc_method_handler(
                    servicer.SetInternalPhaseOffset,
                    request_deserializer=recording__pb2.PhaseOffset.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetReferenceFrequency': grpc.unary_unary_rpc_method_handler(
                    servicer.GetReferenceFrequency,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=recording__pb2.Frequency.SerializeToString,
            ),
            'SetReferenceFrequency': grpc.unary_unary_rpc_method_handler(
                    servicer.SetReferenceFrequency,
                    request_deserializer=recording__pb2.Frequency.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetReferenceDelay': grpc.unary_unary_rpc_method_handler(
                    servicer.GetReferenceDelay,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=recording__pb2.ReferenceDelay.SerializeToString,
            ),
            'SetReferenceDelay': grpc.unary_unary_rpc_method_handler(
                    servicer.SetReferenceDelay,
                    request_deserializer=recording__pb2.ReferenceDelay.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetStateConfig': grpc.unary_unary_rpc_method_handler(
                    servicer.GetStateConfig,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=recording__pb2.StateConfig.SerializeToString,
            ),
            'SetStateConfig': grpc.unary_unary_rpc_method_handler(
                    servicer.SetStateConfig,
                    request_deserializer=recording__pb2.StateConfig.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetAveragedResult': grpc.unary_unary_rpc_method_handler(
                    servicer.GetAveragedResult,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=recording__pb2.IQResult.SerializeToString,
            ),
            'GetSingleResult': grpc.unary_unary_rpc_method_handler(
                    servicer.GetSingleResult,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=recording__pb2.IQResult.SerializeToString,
            ),
            'GetResultMemoryStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.GetResultMemoryStatus,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=recording__pb2.MemoryStatus.SerializeToString,
            ),
            'GetResultMemorySize': grpc.unary_unary_rpc_method_handler(
                    servicer.GetResultMemorySize,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=recording__pb2.MemorySize.SerializeToString,
            ),
            'GetResultMemory': grpc.unary_unary_rpc_method_handler(
                    servicer.GetResultMemory,
                    request_deserializer=recording__pb2.MemorySize.FromString,
                    response_serializer=recording__pb2.ResultMemory.SerializeToString,
            ),
            'GetRawMemory': grpc.unary_unary_rpc_method_handler(
                    servicer.GetRawMemory,
                    request_deserializer=recording__pb2.MemorySize.FromString,
                    response_serializer=recording__pb2.RawMemory.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'recording.Recording', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('recording.Recording', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class Recording(object):
    """Missing associated documentation comment in .proto file."""

    @staticmethod
    def Reset(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,
            '/recording.Recording/Reset',
            datatypes__pb2.EndpointIndex.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ReportStatus(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,
            '/recording.Recording/ReportStatus',
            datatypes__pb2.EndpointIndex.SerializeToString,
            recording__pb2.StatusReport.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ResetStatus(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,
            '/recording.Recording/ResetStatus',
            datatypes__pb2.EndpointIndex.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ResetStatusAll(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,
            '/recording.Recording/ResetStatusAll',
            datatypes__pb2.Empty.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def IsInterferometerMode(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,
            '/recording.Recording/IsInterferometerMode',
            datatypes__pb2.EndpointIndex.SerializeToString,
            recording__pb2.InterferometerMode.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetInterferometerMode(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,
            '/recording.Recording/SetInterferometerMode',
            recording__pb2.InterferometerMode.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def IsContinuousMode(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,
            '/recording.Recording/IsContinuousMode',
            datatypes__pb2.EndpointIndex.SerializeToString,
            recording__pb2.ContinuousMode.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetContinuousMode(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,
            '/recording.Recording/SetContinuousMode',
            recording__pb2.ContinuousMode.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetLastTrigger(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,
            '/recording.Recording/GetLastTrigger',
            datatypes__pb2.EndpointIndex.SerializeToString,
            recording__pb2.Trigger.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def TriggerManually(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,
            '/recording.Recording/TriggerManually',
            recording__pb2.Trigger.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetTriggerOffset(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,
            '/recording.Recording/GetTriggerOffset',
            datatypes__pb2.EndpointIndex.SerializeToString,
            recording__pb2.TriggerOffset.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetTriggerOffset(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,
            '/recording.Recording/SetTriggerOffset',
            recording__pb2.TriggerOffset.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetRecordingDuration(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,
            '/recording.Recording/GetRecordingDuration',
            datatypes__pb2.EndpointIndex.SerializeToString,
            recording__pb2.RecordingDuration.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetRecordingDuration(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,
            '/recording.Recording/SetRecordingDuration',
            recording__pb2.RecordingDuration.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetValueShift(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,
            '/recording.Recording/GetValueShift',
            datatypes__pb2.EndpointIndex.SerializeToString,
            recording__pb2.ValueShift.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetValueShift(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,
            '/recording.Recording/SetValueShift',
            recording__pb2.ValueShift.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetExpectedHighestSignalAmplitude(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,
            '/recording.Recording/GetExpectedHighestSignalAmplitude',
            datatypes__pb2.EndpointIndex.SerializeToString,
            datatypes__pb2.Int.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetExpectedHighestSignalAmplitude(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,
            '/recording.Recording/SetExpectedHighestSignalAmplitude',
            datatypes__pb2.IndexedInt.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetAverageShift(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,
            '/recording.Recording/GetAverageShift',
            datatypes__pb2.EndpointIndex.SerializeToString,
            recording__pb2.AverageShift.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetAverageShift(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,
            '/recording.Recording/SetAverageShift',
            recording__pb2.AverageShift.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetConditioningMatrix(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,
            '/recording.Recording/GetConditioningMatrix',
            datatypes__pb2.EndpointIndex.SerializeToString,
            recording__pb2.ConditioningMatrix.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetConditioningMatrix(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,
            '/recording.Recording/SetConditioningMatrix',
            recording__pb2.ConditioningMatrix.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetConditioningOffset(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,
            '/recording.Recording/GetConditioningOffset',
            datatypes__pb2.EndpointIndex.SerializeToString,
            recording__pb2.ConditioningOffset.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetConditioningOffset(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,
            '/recording.Recording/SetConditioningOffset',
            recording__pb2.ConditioningOffset.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetInternalFrequency(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,
            '/recording.Recording/GetInternalFrequency',
            datatypes__pb2.EndpointIndex.SerializeToString,
            recording__pb2.Frequency.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetInternalFrequency(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,
            '/recording.Recording/SetInternalFrequency',
            recording__pb2.Frequency.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetInternalPhaseOffset(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,
            '/recording.Recording/GetInternalPhaseOffset',
            datatypes__pb2.EndpointIndex.SerializeToString,
            recording__pb2.PhaseOffset.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetInternalPhaseOffset(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,
            '/recording.Recording/SetInternalPhaseOffset',
            recording__pb2.PhaseOffset.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetReferenceFrequency(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,
            '/recording.Recording/GetReferenceFrequency',
            datatypes__pb2.EndpointIndex.SerializeToString,
            recording__pb2.Frequency.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetReferenceFrequency(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,
            '/recording.Recording/SetReferenceFrequency',
            recording__pb2.Frequency.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetReferenceDelay(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,
            '/recording.Recording/GetReferenceDelay',
            datatypes__pb2.EndpointIndex.SerializeToString,
            recording__pb2.ReferenceDelay.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetReferenceDelay(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,
            '/recording.Recording/SetReferenceDelay',
            recording__pb2.ReferenceDelay.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetStateConfig(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,
            '/recording.Recording/GetStateConfig',
            datatypes__pb2.EndpointIndex.SerializeToString,
            recording__pb2.StateConfig.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetStateConfig(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,
            '/recording.Recording/SetStateConfig',
            recording__pb2.StateConfig.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetAveragedResult(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,
            '/recording.Recording/GetAveragedResult',
            datatypes__pb2.EndpointIndex.SerializeToString,
            recording__pb2.IQResult.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetSingleResult(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,
            '/recording.Recording/GetSingleResult',
            datatypes__pb2.EndpointIndex.SerializeToString,
            recording__pb2.IQResult.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetResultMemoryStatus(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,
            '/recording.Recording/GetResultMemoryStatus',
            datatypes__pb2.EndpointIndex.SerializeToString,
            recording__pb2.MemoryStatus.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetResultMemorySize(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,
            '/recording.Recording/GetResultMemorySize',
            datatypes__pb2.EndpointIndex.SerializeToString,
            recording__pb2.MemorySize.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetResultMemory(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,
            '/recording.Recording/GetResultMemory',
            recording__pb2.MemorySize.SerializeToString,
            recording__pb2.ResultMemory.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetRawMemory(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,
            '/recording.Recording/GetRawMemory',
            recording__pb2.MemorySize.SerializeToString,
            recording__pb2.RawMemory.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
