# Generated by the protocol buffer compiler.  DO NOT EDIT!
# sources: qm/grpc/v2/common_types.proto, qm/grpc/v2/job_api.proto, qm/grpc/v2/qm_api.proto, qm/grpc/v2/qmm_api.proto
# plugin: python-betterproto
# This file has been @generated

from dataclasses import dataclass
from datetime import datetime
from typing import (
    TYPE_CHECKING,
    AsyncIterator,
    Dict,
    List,
    Optional,
)

import betterproto
import betterproto.lib.google.protobuf as betterproto_lib_google_protobuf
import grpclib
from betterproto.grpc.grpclib_server import ServiceBase

from .. import (
    compiler as _compiler__,
    frontend as _frontend__,
    job_manager as _job_manager__,
    qm_api as _qm_api__,
    qm_manager as _qm_manager__,
    qua as _qua__,
    qua_config as _qua_config__,
    results_analyser as _results_analyser__,
)


if TYPE_CHECKING:
    import grpclib.server
    from betterproto.grpc.grpclib_client import MetadataLike
    from grpclib.metadata import Deadline


class JobExecutionStatus(betterproto.Enum):
    UNSET = 0
    UNKNOWN = 1
    PENDING = 2
    RUNNING = 3
    COMPLETED = 4
    CANCELED = 5
    LOADING = 6
    ERROR = 7
    PROCESSING = 8


class OpenQuantumMachineRequestCloseMode(betterproto.Enum):
    CLOSE_MODE_UNSPECIFIED = 0
    CLOSE_MODE_IF_NEEDED = 1
    CLOSE_MODE_ALL = 2


class GetControllersResponseFemType(betterproto.Enum):
    FEM_TYPE_UNSPECIFIED = 0
    FEM_TYPE_LF = 1
    FEM_TYPE_MW = 2


class GetControllersResponseControllerType(betterproto.Enum):
    CONTROLLER_TYPE_UNSPECIFIED = 0
    CONTROLLER_TYPE_OPX_1000 = 1


class GetJobErrorsResponseGetJobErrorsResponseSuccessExecutionErrorSeverity(
    betterproto.Enum
):
    ERROR = 0
    WARNING = 1


class PullSamplesResponsePullSamplesResponseSuccessMode(betterproto.Enum):
    ANALOG = 0
    DIGITAL = 1


class SetOscillatorFrequencyRequestUpdateComponentSelection(betterproto.Enum):
    both = 0
    upconverter = 1
    downconverter = 2


@dataclass(eq=False, repr=False)
class GetVersionRequest(betterproto.Message):
    pass


@dataclass(eq=False, repr=False)
class QmmServiceResetDataProcessingRequest(betterproto.Message):
    pass


@dataclass(eq=False, repr=False)
class QmmServiceGetQuantumMachineRequest(betterproto.Message):
    machine_id: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class QmmServiceCloseQuantumMachineRequest(betterproto.Message):
    machine_id: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class HealthCheckRequest(betterproto.Message):
    pass


@dataclass(eq=False, repr=False)
class HealthCheckResponse(betterproto.Message):
    success: "HealthCheckResponseHealthCheckResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "HealthCheckResponseHealthCheckResponseError" = betterproto.message_field(
        2, group="response_oneof"
    )


@dataclass(eq=False, repr=False)
class HealthCheckResponseHealthCheckResponseSuccess(betterproto.Message):
    ok: bool = betterproto.bool_field(2)
    components: Dict[
        str, "HealthCheckResponseHealthCheckResponseSuccess"
    ] = betterproto.map_field(3, betterproto.TYPE_STRING, betterproto.TYPE_MESSAGE)
    details: Dict[str, "betterproto_lib_google_protobuf.Any"] = betterproto.map_field(
        4, betterproto.TYPE_STRING, betterproto.TYPE_MESSAGE
    )


@dataclass(eq=False, repr=False)
class HealthCheckResponseHealthCheckResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class OpenQuantumMachineRequest(betterproto.Message):
    config: "_qua_config__.QuaConfig" = betterproto.message_field(1)
    close_mode: "OpenQuantumMachineRequestCloseMode" = betterproto.enum_field(2)


@dataclass(eq=False, repr=False)
class OpenQuantumMachineResponse(betterproto.Message):
    success: "OpenQuantumMachineResponseOpenQuantumMachineResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "OpenQuantumMachineResponseOpenQuantumMachineResponseError" = (
        betterproto.message_field(2, group="response_oneof")
    )


@dataclass(eq=False, repr=False)
class OpenQuantumMachineResponseOpenQuantumMachineResponseSuccess(betterproto.Message):
    quantum_machine_id: str = betterproto.string_field(1)
    open_qm_warnings: List["_qm_manager__.OpenQmWarning"] = betterproto.message_field(2)


@dataclass(eq=False, repr=False)
class OpenQuantumMachineResponseOpenQuantumMachineResponseError(betterproto.Message):
    config_validation_errors: List[
        "_qm_manager__.ConfigValidationMessage"
    ] = betterproto.message_field(1)
    physical_validation_errors: List[
        "_qm_manager__.PhysicalValidationMessage"
    ] = betterproto.message_field(2)


@dataclass(eq=False, repr=False)
class GetQuantumMachineResponse(betterproto.Message):
    success: "GetQuantumMachineResponseGetQuantumMachineResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "GetQuantumMachineResponseGetQuantumMachineResponseError" = (
        betterproto.message_field(2, group="response_oneof")
    )


@dataclass(eq=False, repr=False)
class GetQuantumMachineResponseGetQuantumMachineResponseSuccess(betterproto.Message):
    machine_id: str = betterproto.string_field(2)
    config: "_qua_config__.QuaConfig" = betterproto.message_field(3)


@dataclass(eq=False, repr=False)
class GetQuantumMachineResponseGetQuantumMachineResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetControllersRequest(betterproto.Message):
    pass


@dataclass(eq=False, repr=False)
class ListOpenQuantumMachinesRequest(betterproto.Message):
    pass


@dataclass(eq=False, repr=False)
class ListOpenQuantumMachinesResponse(betterproto.Message):
    success: "ListOpenQuantumMachinesResponseListOpenQuantumMachinesResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "ListOpenQuantumMachinesResponseListOpenQuantumMachinesResponseError" = (
        betterproto.message_field(2, group="response_oneof")
    )


@dataclass(eq=False, repr=False)
class ListOpenQuantumMachinesResponseListOpenQuantumMachinesResponseSuccess(
    betterproto.Message
):
    machine_ids: List[str] = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class ListOpenQuantumMachinesResponseListOpenQuantumMachinesResponseError(
    betterproto.Message
):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class CloseAllQuantumMachinesRequest(betterproto.Message):
    pass


@dataclass(eq=False, repr=False)
class JobsQueryParams(betterproto.Message):
    quantum_machine_ids: List[str] = betterproto.string_field(1)
    job_ids: List[str] = betterproto.string_field(2)
    user_ids: List[str] = betterproto.string_field(3)
    description: str = betterproto.string_field(4)
    status: List["JobExecutionStatus"] = betterproto.enum_field(5)


@dataclass(eq=False, repr=False)
class JobResponseData(betterproto.Message):
    job_id: str = betterproto.string_field(1)
    description: str = betterproto.string_field(2)
    status: "JobExecutionStatus" = betterproto.enum_field(3)
    metadata: "JobMetadata" = betterproto.message_field(4)


@dataclass(eq=False, repr=False)
class JobMetadata(betterproto.Message):
    created_at: datetime = betterproto.message_field(1)
    started_at: datetime = betterproto.message_field(2)
    last_status_updated_at: datetime = betterproto.message_field(3)


@dataclass(eq=False, repr=False)
class GetJobsRequest(betterproto.Message):
    query: "JobsQueryParams" = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class GetJobResponse(betterproto.Message):
    success: "GetJobResponseGetJobResponseSuccess" = betterproto.message_field(
        1, group="response_oneof"
    )
    error: "GetJobResponseGetJobResponseError" = betterproto.message_field(
        2, group="response_oneof"
    )


@dataclass(eq=False, repr=False)
class GetJobResponseGetJobResponseSuccess(betterproto.Message):
    job: "JobResponseData" = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class GetJobResponseGetJobResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetJobsResponse(betterproto.Message):
    success: "GetJobsSuccess" = betterproto.message_field(1, group="response_oneof")
    error: "GetJobsError" = betterproto.message_field(2, group="response_oneof")


@dataclass(eq=False, repr=False)
class GetJobsError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetJobsSuccess(betterproto.Message):
    jobs: List["JobResponseData"] = betterproto.message_field(2)


@dataclass(eq=False, repr=False)
class GetJobRequest(betterproto.Message):
    job_id: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetControllersResponse(betterproto.Message):
    success: "GetControllersResponseGetControllersResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "GetControllersResponseGetControllersResponseError" = (
        betterproto.message_field(2, group="response_oneof")
    )


@dataclass(eq=False, repr=False)
class GetControllersResponseGetControllersResponseSuccess(betterproto.Message):
    control_devices: Dict[
        str, "GetControllersResponseController"
    ] = betterproto.map_field(1, betterproto.TYPE_STRING, betterproto.TYPE_MESSAGE)


@dataclass(eq=False, repr=False)
class GetControllersResponseGetControllersResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetControllersResponseController(betterproto.Message):
    hostname: str = betterproto.string_field(1)
    controller_type: "GetControllersResponseControllerType" = betterproto.enum_field(2)
    fems: Dict[int, "GetControllersResponseFem"] = betterproto.map_field(
        3, betterproto.TYPE_UINT32, betterproto.TYPE_MESSAGE
    )


@dataclass(eq=False, repr=False)
class GetControllersResponseFem(betterproto.Message):
    type: "GetControllersResponseFemType" = betterproto.enum_field(1)


@dataclass(eq=False, repr=False)
class GetVersionResponse(betterproto.Message):
    success: "GetVersionResponseGetVersionResponseSuccess" = betterproto.message_field(
        1, group="response_oneof"
    )
    error: "GetVersionResponseGetVersionResponseError" = betterproto.message_field(
        2, group="response_oneof"
    )


@dataclass(eq=False, repr=False)
class GetVersionResponseGetVersionResponseSuccess(betterproto.Message):
    gateway: str = betterproto.string_field(2)
    controllers: Dict[str, str] = betterproto.map_field(
        3, betterproto.TYPE_STRING, betterproto.TYPE_STRING
    )


@dataclass(eq=False, repr=False)
class GetVersionResponseGetVersionResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class QmmServiceSimulateRequest(betterproto.Message):
    config: "_qua_config__.QuaConfig" = betterproto.message_field(1)
    high_level_program: "_qua__.QuaProgram" = betterproto.message_field(3)
    simulate: "_frontend__.ExecutionRequestSimulate" = betterproto.message_field(4)
    controller_connections: List[
        "_frontend__.InterOpxConnection"
    ] = betterproto.message_field(5)


@dataclass(eq=False, repr=False)
class QmmServiceSimulateResponse(betterproto.Message):
    success: "SimulationSuccess" = betterproto.message_field(1, group="response_oneof")
    error: "SimulationError" = betterproto.message_field(2, group="response_oneof")


@dataclass(eq=False, repr=False)
class SimulationSuccess(betterproto.Message):
    job_id: str = betterproto.string_field(1)
    messages: List["_compiler__.CompilerMessage"] = betterproto.message_field(2)
    simulated: "_frontend__.SimulatedResponsePart" = betterproto.message_field(3)


@dataclass(eq=False, repr=False)
class SimulationError(betterproto.Message):
    details: str = betterproto.string_field(1)
    config_validation_errors: List[
        "_qm_manager__.ConfigValidationMessage"
    ] = betterproto.message_field(2)
    physical_validation_errors: List[
        "_qm_manager__.PhysicalValidationMessage"
    ] = betterproto.message_field(3)
    messages: List["_compiler__.CompilerMessage"] = betterproto.message_field(4)


@dataclass(eq=False, repr=False)
class ResetDataProcessingResponse(betterproto.Message):
    success: "ResetDataProcessingResponseResetDataProcessingResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "ResetDataProcessingResponseResetDataProcessingResponseError" = (
        betterproto.message_field(2, group="response_oneof")
    )


@dataclass(eq=False, repr=False)
class ResetDataProcessingResponseResetDataProcessingResponseSuccess(
    betterproto.Message
):
    pass


@dataclass(eq=False, repr=False)
class ResetDataProcessingResponseResetDataProcessingResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class CloseQuantumMachineResponse(betterproto.Message):
    success: "CloseQuantumMachineResponseCloseQuantumMachineResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "CloseQuantumMachineResponseCloseQuantumMachineResponseError" = (
        betterproto.message_field(2, group="response_oneof")
    )


@dataclass(eq=False, repr=False)
class CloseQuantumMachineResponseCloseQuantumMachineResponseSuccess(
    betterproto.Message
):
    pass


@dataclass(eq=False, repr=False)
class CloseQuantumMachineResponseCloseQuantumMachineResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class CloseAllQuantumMachinesResponse(betterproto.Message):
    success: "CloseAllQuantumMachinesResponseCloseAllQuantumMachinesResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "CloseAllQuantumMachinesResponseCloseAllQuantumMachinesResponseError" = (
        betterproto.message_field(2, group="response_oneof")
    )


@dataclass(eq=False, repr=False)
class CloseAllQuantumMachinesResponseCloseAllQuantumMachinesResponseSuccess(
    betterproto.Message
):
    pass


@dataclass(eq=False, repr=False)
class CloseAllQuantumMachinesResponseCloseAllQuantumMachinesResponseError(
    betterproto.Message
):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class ClearAllJobResultsRequest(betterproto.Message):
    pass


@dataclass(eq=False, repr=False)
class ClearAllJobResultsResponse(betterproto.Message):
    success: "ClearAllJobResultsResponseClearAllJobResultsResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "ClearAllJobResultsResponseClearAllJobResultsResponseError" = (
        betterproto.message_field(2, group="response_oneof")
    )


@dataclass(eq=False, repr=False)
class ClearAllJobResultsResponseClearAllJobResultsResponseSuccess(betterproto.Message):
    pass


@dataclass(eq=False, repr=False)
class ClearAllJobResultsResponseClearAllJobResultsResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class QmServiceGetConfigRequest(betterproto.Message):
    quantum_machine_id: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class UpdateConfigRequest(betterproto.Message):
    quantum_machine_id: str = betterproto.string_field(1)
    config: "_qua_config__.QuaConfig" = betterproto.message_field(2)


@dataclass(eq=False, repr=False)
class UpdateConfigResponse(betterproto.Message):
    success: "UpdateConfigResponseUpdateConfigResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "UpdateConfigResponseUpdateConfigResponseError" = betterproto.message_field(
        2, group="response_oneof"
    )


@dataclass(eq=False, repr=False)
class UpdateConfigResponseUpdateConfigResponseSuccess(betterproto.Message):
    pass


@dataclass(eq=False, repr=False)
class UpdateConfigResponseUpdateConfigResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class QmServiceCloseRequest(betterproto.Message):
    quantum_machine_id: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class QmServiceCloseResponse(betterproto.Message):
    success: "QmServiceCloseResponseQmServiceCloseResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "QmServiceCloseResponseQmServiceCloseResponseError" = (
        betterproto.message_field(2, group="response_oneof")
    )


@dataclass(eq=False, repr=False)
class QmServiceCloseResponseQmServiceCloseResponseSuccess(betterproto.Message):
    pass


@dataclass(eq=False, repr=False)
class QmServiceCloseResponseQmServiceCloseResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class QmServiceSimulateRequest(betterproto.Message):
    quantum_machine_id: str = betterproto.string_field(1)
    high_level_program: "_qua__.QuaProgram" = betterproto.message_field(2)
    simulate: "_frontend__.ExecutionRequestSimulate" = betterproto.message_field(3)
    controller_connections: List[
        "_frontend__.InterOpxConnection"
    ] = betterproto.message_field(4)


@dataclass(eq=False, repr=False)
class QmServiceSimulateResponse(betterproto.Message):
    success: "SimulationSuccess" = betterproto.message_field(1, group="response_oneof")
    error: "SimulationError" = betterproto.message_field(2, group="response_oneof")


@dataclass(eq=False, repr=False)
class QmServiceJobsQueryParams(betterproto.Message):
    quantum_machine_id: str = betterproto.string_field(1)
    job_ids: List[str] = betterproto.string_field(2)
    user_ids: List[str] = betterproto.string_field(3)
    description: str = betterproto.string_field(4)
    status: List["JobExecutionStatus"] = betterproto.enum_field(5)


@dataclass(eq=False, repr=False)
class QmServiceGetJobsRequest(betterproto.Message):
    query: "JobsQueryParams" = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class RemoveJobsRequest(betterproto.Message):
    query: "JobsQueryParams" = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class RemoveJobsResponse(betterproto.Message):
    success: "RemoveJobsResponseRemoveJobsResponseSuccess" = betterproto.message_field(
        1, group="response_oneof"
    )
    error: "RemoveJobsResponseRemoveJobsResponseError" = betterproto.message_field(
        2, group="response_oneof"
    )


@dataclass(eq=False, repr=False)
class RemoveJobsResponseRemoveJobsResponseSuccess(betterproto.Message):
    removed_job_ids: List[str] = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class RemoveJobsResponseRemoveJobsResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class QmServiceGetConfigResponse(betterproto.Message):
    success: "GetConfigSuccess" = betterproto.message_field(1, group="response_oneof")
    error: "GetConfigError" = betterproto.message_field(2, group="response_oneof")


@dataclass(eq=False, repr=False)
class GetConfigSuccess(betterproto.Message):
    config: "_qua_config__.QuaConfig" = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class GetConfigError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class QmServiceCompileRequest(betterproto.Message):
    quantum_machine_id: str = betterproto.string_field(1)
    high_level_program: "_qua__.QuaProgram" = betterproto.message_field(2)


@dataclass(eq=False, repr=False)
class CompileResponse(betterproto.Message):
    success: "CompileResponseCompilationSuccess" = betterproto.message_field(
        1, group="response_oneof"
    )
    error: "CompileResponseCompilationError" = betterproto.message_field(
        2, group="response_oneof"
    )


@dataclass(eq=False, repr=False)
class CompileResponseCompilationSuccess(betterproto.Message):
    program_id: str = betterproto.string_field(1)
    messages: List["_compiler__.CompilerMessage"] = betterproto.message_field(2)


@dataclass(eq=False, repr=False)
class CompileResponseCompilationError(betterproto.Message):
    details: str = betterproto.string_field(1)
    messages: List["_compiler__.CompilerMessage"] = betterproto.message_field(2)


@dataclass(eq=False, repr=False)
class ExecuteRequest(betterproto.Message):
    quantum_machine_id: str = betterproto.string_field(1)
    high_level_program: "_qua__.QuaProgram" = betterproto.message_field(2)


@dataclass(eq=False, repr=False)
class ExecuteResponse(betterproto.Message):
    success: "ExecuteResponseExecuteResponseSuccess" = betterproto.message_field(
        1, group="response_oneof"
    )
    error: "ExecuteResponseExecuteResponseError" = betterproto.message_field(
        2, group="response_oneof"
    )


@dataclass(eq=False, repr=False)
class ExecuteResponseExecuteResponseSuccess(betterproto.Message):
    job_id: str = betterproto.string_field(1)
    messages: List["_compiler__.CompilerMessage"] = betterproto.message_field(2)


@dataclass(eq=False, repr=False)
class ExecuteResponseExecuteResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)
    messages: List["_compiler__.CompilerMessage"] = betterproto.message_field(2)


@dataclass(eq=False, repr=False)
class QmServiceAddToQueueRequest(betterproto.Message):
    quantum_machine_id: str = betterproto.string_field(1)
    high_level_program: "_qua__.QuaProgram" = betterproto.message_field(2)
    queue_position: "_frontend__.QueuePosition" = betterproto.message_field(3)


@dataclass(eq=False, repr=False)
class AddToQueueResponse(betterproto.Message):
    success: "AddToQueueResponseAddToQueueResponseSuccess" = betterproto.message_field(
        1, group="response_oneof"
    )
    error: "AddToQueueResponseAddToQueueResponseError" = betterproto.message_field(
        2, group="response_oneof"
    )


@dataclass(eq=False, repr=False)
class AddToQueueResponseAddToQueueResponseSuccess(betterproto.Message):
    job_id: str = betterproto.string_field(1)
    messages: List["_compiler__.CompilerMessage"] = betterproto.message_field(2)


@dataclass(eq=False, repr=False)
class AddToQueueResponseAddToQueueResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)
    messages: List["_compiler__.CompilerMessage"] = betterproto.message_field(2)


@dataclass(eq=False, repr=False)
class QmServiceAddCompiledToQueueRequest(betterproto.Message):
    quantum_machine_id: str = betterproto.string_field(1)
    program_id: str = betterproto.string_field(2)


@dataclass(eq=False, repr=False)
class AddCompiledToQueueResponse(betterproto.Message):
    success: "AddCompiledToQueueResponseAddCompiledToQueueResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "AddCompiledToQueueResponseAddCompiledToQueueResponseError" = (
        betterproto.message_field(2, group="response_oneof")
    )


@dataclass(eq=False, repr=False)
class AddCompiledToQueueResponseAddCompiledToQueueResponseSuccess(betterproto.Message):
    job_id: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class AddCompiledToQueueResponseAddCompiledToQueueResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class QmServiceGetJobsResponse(betterproto.Message):
    success: "GetJobsSuccess" = betterproto.message_field(1, group="response_oneof")
    error: "GetJobsError" = betterproto.message_field(2, group="response_oneof")


@dataclass(eq=False, repr=False)
class SetMatrixCorrectionResponse(betterproto.Message):
    success: "SetMatrixCorrectionResponseSetMatrixCorrectionResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "SetMatrixCorrectionResponseSetMatrixCorrectionResponseError" = (
        betterproto.message_field(2, group="response_oneof")
    )


@dataclass(eq=False, repr=False)
class SetMatrixCorrectionResponseSetMatrixCorrectionResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class SetMatrixCorrectionResponseSetMatrixCorrectionResponseSuccess(
    betterproto.Message
):
    pass


@dataclass(eq=False, repr=False)
class SetIntermediateFrequencyResponse(betterproto.Message):
    success: "SetIntermediateFrequencyResponseSetIntermediateFrequencyResponseSuccess" = betterproto.message_field(
        1, group="response_oneof"
    )
    error: "SetIntermediateFrequencyResponseSetIntermediateFrequencyResponseError" = (
        betterproto.message_field(2, group="response_oneof")
    )


@dataclass(eq=False, repr=False)
class SetIntermediateFrequencyResponseSetIntermediateFrequencyResponseError(
    betterproto.Message
):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class SetIntermediateFrequencyResponseSetIntermediateFrequencyResponseSuccess(
    betterproto.Message
):
    pass


@dataclass(eq=False, repr=False)
class SetDigitalDelayResponse(betterproto.Message):
    success: "SetDigitalDelayResponseSetDigitalDelayResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "SetDigitalDelayResponseSetDigitalDelayResponseError" = (
        betterproto.message_field(2, group="response_oneof")
    )


@dataclass(eq=False, repr=False)
class SetDigitalDelayResponseSetDigitalDelayResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class SetDigitalDelayResponseSetDigitalDelayResponseSuccess(betterproto.Message):
    pass


@dataclass(eq=False, repr=False)
class SetDigitalBufferResponse(betterproto.Message):
    success: "SetDigitalBufferResponseSetDigitalBufferResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "SetDigitalBufferResponseSetDigitalBufferResponseError" = (
        betterproto.message_field(2, group="response_oneof")
    )


@dataclass(eq=False, repr=False)
class SetDigitalBufferResponseSetDigitalBufferResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class SetDigitalBufferResponseSetDigitalBufferResponseSuccess(betterproto.Message):
    pass


@dataclass(eq=False, repr=False)
class SetInputDcOffsetResponse(betterproto.Message):
    success: "SetInputDcOffsetResponseSetInputDcOffsetResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "SetInputDcOffsetResponseSetInputDcOffsetResponseError" = (
        betterproto.message_field(2, group="response_oneof")
    )


@dataclass(eq=False, repr=False)
class SetInputDcOffsetResponseSetInputDcOffsetResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class SetInputDcOffsetResponseSetInputDcOffsetResponseSuccess(betterproto.Message):
    pass


@dataclass(eq=False, repr=False)
class SetOutputDcOffsetResponse(betterproto.Message):
    success: "SetOutputDcOffsetResponseSetOutputDcOffsetResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "SetOutputDcOffsetResponseSetOutputDcOffsetResponseError" = (
        betterproto.message_field(2, group="response_oneof")
    )


@dataclass(eq=False, repr=False)
class SetOutputDcOffsetResponseSetOutputDcOffsetResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class SetOutputDcOffsetResponseSetOutputDcOffsetResponseSuccess(betterproto.Message):
    pass


@dataclass(eq=False, repr=False)
class SetIoValuesResponse(betterproto.Message):
    success: "SetIoValuesResponseSetIoValuesResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "SetIoValuesResponseSetIoValuesResponseError" = betterproto.message_field(
        2, group="response_oneof"
    )


@dataclass(eq=False, repr=False)
class SetIoValuesResponseSetIoValuesResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class SetIoValuesResponseSetIoValuesResponseSuccess(betterproto.Message):
    pass


@dataclass(eq=False, repr=False)
class SetIoValuesRequest(betterproto.Message):
    job_id: str = betterproto.string_field(1)
    io1: "SetIoValuesRequestIoValueSetData" = betterproto.message_field(2)
    io2: "SetIoValuesRequestIoValueSetData" = betterproto.message_field(3)


@dataclass(eq=False, repr=False)
class SetIoValuesRequestIoValueSetData(betterproto.Message):
    int_value: int = betterproto.int32_field(2, group="oneof_IO_type")
    double_value: float = betterproto.double_field(3, group="oneof_IO_type")
    boolean_value: bool = betterproto.bool_field(4, group="oneof_IO_type")


@dataclass(eq=False, repr=False)
class GetIoValuesRequest(betterproto.Message):
    job_id: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class IoValuesData(betterproto.Message):
    int_value: int = betterproto.uint32_field(1)
    double_value: float = betterproto.double_field(2)
    boolean_value: bool = betterproto.bool_field(3)


@dataclass(eq=False, repr=False)
class GetIoValuesResponse(betterproto.Message):
    success: "GetIoValuesResponseGetIoValuesResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "GetIoValuesResponseGetIoValuesResponseError" = betterproto.message_field(
        2, group="response_oneof"
    )


@dataclass(eq=False, repr=False)
class GetIoValuesResponseGetIoValuesResponseSuccess(betterproto.Message):
    io1: "GetIoValuesResponseGetIoValuesResponseSuccessIoValuesData" = (
        betterproto.message_field(1)
    )
    io2: "GetIoValuesResponseGetIoValuesResponseSuccessIoValuesData" = (
        betterproto.message_field(2)
    )


@dataclass(eq=False, repr=False)
class GetIoValuesResponseGetIoValuesResponseSuccessIoValuesData(betterproto.Message):
    int_value: int = betterproto.uint32_field(1)
    double_value: float = betterproto.double_field(2)
    boolean_value: bool = betterproto.bool_field(3)


@dataclass(eq=False, repr=False)
class GetIoValuesResponseGetIoValuesResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class JobServiceIsPausedRequest(betterproto.Message):
    job_id: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class IsPausedResponse(betterproto.Message):
    error: "IsPausedResponseIsPausedResponseError" = betterproto.message_field(
        1, group="response_oneof"
    )
    success: "IsPausedResponseIsPausedResponseSuccess" = betterproto.message_field(
        2, group="response_oneof"
    )


@dataclass(eq=False, repr=False)
class IsPausedResponseIsPausedResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class IsPausedResponseIsPausedResponseSuccess(betterproto.Message):
    is_paused: bool = betterproto.bool_field(1)


@dataclass(eq=False, repr=False)
class JobServiceGetConfigRequest(betterproto.Message):
    job_id: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class JobServiceGetJobStatusRequest(betterproto.Message):
    job_id: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class ResumeRequest(betterproto.Message):
    job_id: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class ResumeResponse(betterproto.Message):
    success: "ResumeResponseResumeResponseSuccess" = betterproto.message_field(
        1, group="response_oneof"
    )
    error: "ResumeResponseResumeResponseError" = betterproto.message_field(
        2, group="response_oneof"
    )


@dataclass(eq=False, repr=False)
class ResumeResponseResumeResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class ResumeResponseResumeResponseSuccess(betterproto.Message):
    pass


@dataclass(eq=False, repr=False)
class SetMatrixCorrectionRequest(betterproto.Message):
    job_id: str = betterproto.string_field(1)
    qe: str = betterproto.string_field(2)
    correction: "_qm_api__.Matrix" = betterproto.message_field(3)


@dataclass(eq=False, repr=False)
class SetIntermediateFrequencyRequest(betterproto.Message):
    job_id: str = betterproto.string_field(1)
    qe: str = betterproto.string_field(2)
    frequency: float = betterproto.double_field(3)


@dataclass(eq=False, repr=False)
class SetDigitalDelayRequest(betterproto.Message):
    job_id: str = betterproto.string_field(1)
    qe: str = betterproto.string_field(2)
    port: str = betterproto.string_field(3)
    delay: int = betterproto.uint32_field(4)


@dataclass(eq=False, repr=False)
class SetDigitalBufferRequest(betterproto.Message):
    job_id: str = betterproto.string_field(1)
    qe: str = betterproto.string_field(2)
    port: str = betterproto.string_field(3)
    buffer: int = betterproto.uint32_field(4)


@dataclass(eq=False, repr=False)
class SetInputDcOffsetRequest(betterproto.Message):
    job_id: str = betterproto.string_field(1)
    qe: str = betterproto.string_field(2)
    port: str = betterproto.string_field(3)
    offset: float = betterproto.double_field(4)


@dataclass(eq=False, repr=False)
class SetOutputDcOffsetRequest(betterproto.Message):
    job_id: str = betterproto.string_field(1)
    qe: str = betterproto.string_field(2)
    mix_inputs: "MixInputsDcOffset" = betterproto.message_field(
        3, group="oneof_element_input_type"
    )
    single_input: "SingleInputDcOffset" = betterproto.message_field(
        4, group="oneof_element_input_type"
    )


@dataclass(eq=False, repr=False)
class GetMatrixCorrectionRequest(betterproto.Message):
    job_id: str = betterproto.string_field(1)
    qe: str = betterproto.string_field(2)


@dataclass(eq=False, repr=False)
class GetMatrixCorrectionError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetMatrixCorrectionResponse(betterproto.Message):
    error: "GetMatrixCorrectionResponseGetMatrixCorrectionResponseError" = (
        betterproto.message_field(1, group="response_oneof")
    )
    success: "GetMatrixCorrectionResponseGetMatrixCorrectionResponseSuccess" = (
        betterproto.message_field(2, group="response_oneof")
    )


@dataclass(eq=False, repr=False)
class GetMatrixCorrectionResponseGetMatrixCorrectionResponseSuccess(
    betterproto.Message
):
    correction: "_qm_api__.Matrix" = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class GetMatrixCorrectionResponseGetMatrixCorrectionResponseError(betterproto.Message):
    error: "GetMatrixCorrectionError" = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class GetIntermediateFrequencyRequest(betterproto.Message):
    job_id: str = betterproto.string_field(1)
    qe: str = betterproto.string_field(2)


@dataclass(eq=False, repr=False)
class GetIntermediateFrequencyResponse(betterproto.Message):
    error: "GetIntermediateFrequencyResponseGetIntermediateFrequencyResponseError" = (
        betterproto.message_field(1, group="response_oneof")
    )
    success: "GetIntermediateFrequencyResponseGetIntermediateFrequencyResponseSuccess" = betterproto.message_field(
        2, group="response_oneof"
    )


@dataclass(eq=False, repr=False)
class GetIntermediateFrequencyResponseGetIntermediateFrequencyResponseError(
    betterproto.Message
):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetIntermediateFrequencyResponseGetIntermediateFrequencyResponseSuccess(
    betterproto.Message
):
    frequency: float = betterproto.double_field(1)


@dataclass(eq=False, repr=False)
class GetDigitalDelayRequest(betterproto.Message):
    job_id: str = betterproto.string_field(1)
    qe: str = betterproto.string_field(2)
    port: str = betterproto.string_field(3)


@dataclass(eq=False, repr=False)
class GetDigitalDelayResponse(betterproto.Message):
    success: "GetDigitalDelayResponseGetDigitalDelayResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "GetDigitalDelayResponseGetDigitalDelayResponseError" = (
        betterproto.message_field(2, group="response_oneof")
    )


@dataclass(eq=False, repr=False)
class GetDigitalDelayResponseGetDigitalDelayResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetDigitalDelayResponseGetDigitalDelayResponseSuccess(betterproto.Message):
    delay: int = betterproto.uint32_field(1)


@dataclass(eq=False, repr=False)
class GetDigitalBufferRequest(betterproto.Message):
    job_id: str = betterproto.string_field(1)
    qe: str = betterproto.string_field(2)
    port: str = betterproto.string_field(3)


@dataclass(eq=False, repr=False)
class GetDigitalBufferResponse(betterproto.Message):
    success: "GetDigitalBufferResponseGetDigitalBufferResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "GetDigitalBufferResponseGetDigitalBufferResponseError" = (
        betterproto.message_field(2, group="response_oneof")
    )


@dataclass(eq=False, repr=False)
class GetDigitalBufferResponseGetDigitalBufferResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetDigitalBufferResponseGetDigitalBufferResponseSuccess(betterproto.Message):
    buffer: int = betterproto.uint32_field(1)


@dataclass(eq=False, repr=False)
class GetInputDcOffsetRequest(betterproto.Message):
    job_id: str = betterproto.string_field(1)
    qe: str = betterproto.string_field(2)
    port: str = betterproto.string_field(3)


@dataclass(eq=False, repr=False)
class GetInputDcOffsetError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetInputDcOffsetSuccess(betterproto.Message):
    offset: float = betterproto.double_field(1)


@dataclass(eq=False, repr=False)
class GetInputDcOffsetResponse(betterproto.Message):
    success: "GetInputDcOffsetResponseGetInputDcOffsetResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "GetInputDcOffsetResponseGetInputDcOffsetResponseError" = (
        betterproto.message_field(2, group="response_oneof")
    )


@dataclass(eq=False, repr=False)
class GetInputDcOffsetResponseGetInputDcOffsetResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetInputDcOffsetResponseGetInputDcOffsetResponseSuccess(betterproto.Message):
    offset: float = betterproto.double_field(1)


@dataclass(eq=False, repr=False)
class GetOutputDcOffsetRequest(betterproto.Message):
    job_id: str = betterproto.string_field(1)
    qe: str = betterproto.string_field(2)


@dataclass(eq=False, repr=False)
class GetOutputDcOffsetResponse(betterproto.Message):
    success: "GetOutputDcOffsetResponseGetOutputDcOffsetResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "GetOutputDcOffsetResponseGetOutputDcOffsetResponseError" = (
        betterproto.message_field(2, group="response_oneof")
    )


@dataclass(eq=False, repr=False)
class GetOutputDcOffsetResponseGetOutputDcOffsetResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetOutputDcOffsetResponseGetOutputDcOffsetResponseSuccess(betterproto.Message):
    mix_inputs: "MixInputsDcOffset" = betterproto.message_field(
        2, group="oneof_element_input_type"
    )
    single_input: "SingleInputDcOffset" = betterproto.message_field(
        3, group="oneof_element_input_type"
    )


@dataclass(eq=False, repr=False)
class MixInputsDcOffset(betterproto.Message):
    i: Optional[float] = betterproto.double_field(1, optional=True)
    q: Optional[float] = betterproto.double_field(2, optional=True)


@dataclass(eq=False, repr=False)
class SingleInputDcOffset(betterproto.Message):
    offset: float = betterproto.double_field(1)


@dataclass(eq=False, repr=False)
class JobServiceGetConfigResponse(betterproto.Message):
    success: "GetConfigSuccess" = betterproto.message_field(1, group="response_oneof")
    error: "GetConfigError" = betterproto.message_field(2, group="response_oneof")


@dataclass(eq=False, repr=False)
class JobServiceGetJobStatusResponse(betterproto.Message):
    success: "JobServiceGetJobStatusResponseJobServiceGetJobStatusResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "JobServiceGetJobStatusResponseJobServiceGetJobStatusResponseError" = (
        betterproto.message_field(2, group="response_oneof")
    )


@dataclass(eq=False, repr=False)
class JobServiceGetJobStatusResponseJobServiceGetJobStatusResponseError(
    betterproto.Message
):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class JobServiceGetJobStatusResponseJobServiceGetJobStatusResponseSuccess(
    betterproto.Message
):
    status: "JobExecutionStatus" = betterproto.enum_field(1)


@dataclass(eq=False, repr=False)
class JobServicePushToInputStreamRequest(betterproto.Message):
    job_id: str = betterproto.string_field(1)
    stream_name: str = betterproto.string_field(2)
    int_stream_data: "_job_manager__.IntStreamData" = betterproto.message_field(
        3, group="stream_data_oneof"
    )
    fixed_stream_data: "_job_manager__.FixedStreamData" = betterproto.message_field(
        4, group="stream_data_oneof"
    )
    bool_stream_data: "_job_manager__.BoolStreamData" = betterproto.message_field(
        5, group="stream_data_oneof"
    )


@dataclass(eq=False, repr=False)
class PushToInputStreamResponse(betterproto.Message):
    success: "PushToInputStreamResponsePushToInputStreamResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "PushToInputStreamResponsePushToInputStreamResponseError" = (
        betterproto.message_field(2, group="response_oneof")
    )


@dataclass(eq=False, repr=False)
class PushToInputStreamResponsePushToInputStreamResponseSuccess(betterproto.Message):
    pass


@dataclass(eq=False, repr=False)
class PushToInputStreamResponsePushToInputStreamResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)
    """
    todo - there is a detailed response in the previous API, needs to be added here
    """


@dataclass(eq=False, repr=False)
class GetJobResultSchemaRequest(betterproto.Message):
    job_id: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetJobResultSchemaResponse(betterproto.Message):
    success: "GetJobResultSchemaResponseGetJobResultSchemaResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "GetJobResultSchemaResponseGetJobResultSchemaResponseError" = (
        betterproto.message_field(2, group="response_oneof")
    )


@dataclass(eq=False, repr=False)
class GetJobResultSchemaResponseGetJobResultSchemaResponseSuccess(betterproto.Message):
    items: List[
        "GetJobResultSchemaResponseGetJobResultSchemaResponseSuccessItem"
    ] = betterproto.message_field(1)
    """TODO - check if this is the best schema"""


@dataclass(eq=False, repr=False)
class GetJobResultSchemaResponseGetJobResultSchemaResponseSuccessItem(
    betterproto.Message
):
    name: str = betterproto.string_field(1)
    simple_dtype: str = betterproto.string_field(2)
    is_single: bool = betterproto.bool_field(3)
    expected_count: int = betterproto.int32_field(4)
    shape: List[int] = betterproto.int32_field(5)


@dataclass(eq=False, repr=False)
class GetJobResultSchemaResponseGetJobResultSchemaResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetJobNamedResultHeaderRequest(betterproto.Message):
    job_id: str = betterproto.string_field(1)
    output_name: str = betterproto.string_field(2)
    flat_format: bool = betterproto.bool_field(3)


@dataclass(eq=False, repr=False)
class GetJobNamedResultHeaderResponse(betterproto.Message):
    success: "GetJobNamedResultHeaderResponseGetJobNamedResultHeaderResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "GetJobNamedResultHeaderResponseGetJobNamedResultHeaderResponseError" = (
        betterproto.message_field(2, group="response_oneof")
    )


@dataclass(eq=False, repr=False)
class GetJobNamedResultHeaderResponseGetJobNamedResultHeaderResponseError(
    betterproto.Message
):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetJobNamedResultHeaderResponseGetJobNamedResultHeaderResponseSuccess(
    betterproto.Message
):
    is_single: bool = betterproto.bool_field(1)
    count_so_far: int = betterproto.int32_field(2)
    simple_dtype: str = betterproto.string_field(3)
    has_data_loss: bool = betterproto.bool_field(4)
    shape: List[int] = betterproto.int32_field(5)


@dataclass(eq=False, repr=False)
class GetProgramMetadataRequest(betterproto.Message):
    job_id: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetProgramMetadataResponse(betterproto.Message):
    success: "GetProgramMetadataResponseGetProgramMetadataResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "GetProgramMetadataResponseGetProgramMetadataResponseError" = (
        betterproto.message_field(2, group="response_oneof")
    )


@dataclass(eq=False, repr=False)
class GetProgramMetadataResponseGetProgramMetadataResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetProgramMetadataResponseGetProgramMetadataResponseSuccess(betterproto.Message):
    program_stream_metadata: "_results_analyser__.ProgramStreamMetadata" = (
        betterproto.message_field(1)
    )


@dataclass(eq=False, repr=False)
class GetNamedResultRequest(betterproto.Message):
    job_id: str = betterproto.string_field(1)
    output_name: str = betterproto.string_field(2)
    limit: int = betterproto.int32_field(3)
    long_offset: Optional[int] = betterproto.message_field(
        5, wraps=betterproto.TYPE_INT64
    )


@dataclass(eq=False, repr=False)
class GetNamedResultResponse(betterproto.Message):
    success: "GetNamedResultResponseGetNamedResultResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "GetNamedResultResponseGetNamedResultResponseError" = (
        betterproto.message_field(2, group="response_oneof")
    )


@dataclass(eq=False, repr=False)
class GetNamedResultResponseGetNamedResultResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetNamedResultResponseGetNamedResultResponseSuccess(betterproto.Message):
    count_of_items: int = betterproto.int32_field(1)
    data: bytes = betterproto.bytes_field(2)


@dataclass(eq=False, repr=False)
class GetJobErrorsRequest(betterproto.Message):
    job_id: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetJobErrorsResponse(betterproto.Message):
    success: "GetJobErrorsResponseGetJobErrorsResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "GetJobErrorsResponseGetJobErrorsResponseError" = betterproto.message_field(
        2, group="response_oneof"
    )


@dataclass(eq=False, repr=False)
class GetJobErrorsResponseGetJobErrorsResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetJobErrorsResponseGetJobErrorsResponseSuccess(betterproto.Message):
    errors: List[
        "GetJobErrorsResponseGetJobErrorsResponseSuccessError"
    ] = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class GetJobErrorsResponseGetJobErrorsResponseSuccessError(betterproto.Message):
    error_code: int = betterproto.int32_field(1)
    error_severity: "GetJobErrorsResponseGetJobErrorsResponseSuccessExecutionErrorSeverity" = betterproto.enum_field(
        2
    )
    message: str = betterproto.string_field(3)


@dataclass(eq=False, repr=False)
class CancelRequest(betterproto.Message):
    job_id: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class CancelResponse(betterproto.Message):
    success: "CancelResponseCancelJobSuccess" = betterproto.message_field(
        1, group="response_oneof"
    )
    error: "CancelResponseCancelJobError" = betterproto.message_field(
        2, group="response_oneof"
    )


@dataclass(eq=False, repr=False)
class CancelResponseCancelJobError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class CancelResponseCancelJobSuccess(betterproto.Message):
    pass


@dataclass(eq=False, repr=False)
class GetJobResultStateRequest(betterproto.Message):
    job_id: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetJobResultStateResponse(betterproto.Message):
    success: "GetJobResultStateResponseGetJobResultStateResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "GetJobResultStateResponseGetJobResultStateResponseError" = (
        betterproto.message_field(2, group="response_oneof")
    )


@dataclass(eq=False, repr=False)
class GetJobResultStateResponseGetJobResultStateResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetJobResultStateResponseGetJobResultStateResponseSuccess(betterproto.Message):
    done: bool = betterproto.bool_field(1)
    closed: bool = betterproto.bool_field(2)
    has_dataloss: bool = betterproto.bool_field(3)


@dataclass(eq=False, repr=False)
class PullSamplesRequest(betterproto.Message):
    job_id: str = betterproto.string_field(1)
    include_analog: bool = betterproto.bool_field(2)
    include_digital: bool = betterproto.bool_field(3)


@dataclass(eq=False, repr=False)
class PullSamplesResponse(betterproto.Message):
    success: "PullSamplesResponsePullSamplesResponseSuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "PullSamplesResponsePullSamplesResponseError" = betterproto.message_field(
        2, group="response_oneof"
    )


@dataclass(eq=False, repr=False)
class PullSamplesResponsePullSamplesResponseError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class PullSamplesResponsePullSamplesResponseSuccess(betterproto.Message):
    controller: str = betterproto.string_field(1)
    fem_id: int = betterproto.int32_field(2)
    port_id: int = betterproto.int32_field(3)
    mode: "PullSamplesResponsePullSamplesResponseSuccessMode" = betterproto.enum_field(
        4
    )
    double_data: "PullSamplesResponsePullSamplesResponseSuccessDoubleData" = (
        betterproto.message_field(5, group="data")
    )
    boolean_data: "PullSamplesResponsePullSamplesResponseSuccessBooleanData" = (
        betterproto.message_field(6, group="data")
    )


@dataclass(eq=False, repr=False)
class PullSamplesResponsePullSamplesResponseSuccessDoubleData(betterproto.Message):
    mw: "PullSamplesResponsePullSamplesResponseSuccessMw" = betterproto.message_field(
        1, group="output"
    )
    lf: "PullSamplesResponsePullSamplesResponseSuccessLf" = betterproto.message_field(
        2, group="output"
    )


@dataclass(eq=False, repr=False)
class PullSamplesResponsePullSamplesResponseSuccessMw(betterproto.Message):
    duc_id: int = betterproto.int32_field(1)
    i: List[float] = betterproto.double_field(2)
    q: List[float] = betterproto.double_field(3)


@dataclass(eq=False, repr=False)
class PullSamplesResponsePullSamplesResponseSuccessLf(betterproto.Message):
    items: List[float] = betterproto.double_field(1)


@dataclass(eq=False, repr=False)
class PullSamplesResponsePullSamplesResponseSuccessBooleanData(betterproto.Message):
    data: List[
        "PullSamplesResponsePullSamplesResponseSuccessBooleanDataData"
    ] = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class PullSamplesResponsePullSamplesResponseSuccessBooleanDataData(betterproto.Message):
    item: List[bool] = betterproto.bool_field(1)


@dataclass(eq=False, repr=False)
class SetOscillatorFrequencyRequest(betterproto.Message):
    job_id: str = betterproto.string_field(1)
    qe: str = betterproto.string_field(2)
    new_frequency_hz: float = betterproto.double_field(3)
    update_component: "SetOscillatorFrequencyRequestUpdateComponentSelection" = (
        betterproto.enum_field(4)
    )


@dataclass(eq=False, repr=False)
class SetOscillatorFrequencyResponse(betterproto.Message):
    success: "SetOscillatorFrequencyResponseChangeOscillatorFrequencySuccess" = (
        betterproto.message_field(1, group="response_oneof")
    )
    error: "SetOscillatorFrequencyResponseChangeOscillatorFrequencyError" = (
        betterproto.message_field(2, group="response_oneof")
    )


@dataclass(eq=False, repr=False)
class SetOscillatorFrequencyResponseChangeOscillatorFrequencyError(betterproto.Message):
    details: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class SetOscillatorFrequencyResponseChangeOscillatorFrequencySuccess(
    betterproto.Message
):
    pass


class QmmServiceStub(betterproto.ServiceStub):
    async def get_version(
        self,
        get_version_request: "GetVersionRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetVersionResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.QmmService/GetVersion",
            get_version_request,
            GetVersionResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def health_check(
        self,
        health_check_request: "HealthCheckRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "HealthCheckResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.QmmService/HealthCheck",
            health_check_request,
            HealthCheckResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_controllers(
        self,
        get_controllers_request: "GetControllersRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetControllersResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.QmmService/GetControllers",
            get_controllers_request,
            GetControllersResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def open_quantum_machine(
        self,
        open_quantum_machine_request: "OpenQuantumMachineRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "OpenQuantumMachineResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.QmmService/OpenQuantumMachine",
            open_quantum_machine_request,
            OpenQuantumMachineResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_quantum_machine(
        self,
        qmm_service_get_quantum_machine_request: "QmmServiceGetQuantumMachineRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetQuantumMachineResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.QmmService/GetQuantumMachine",
            qmm_service_get_quantum_machine_request,
            GetQuantumMachineResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def list_open_quantum_machines(
        self,
        list_open_quantum_machines_request: "ListOpenQuantumMachinesRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "ListOpenQuantumMachinesResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.QmmService/ListOpenQuantumMachines",
            list_open_quantum_machines_request,
            ListOpenQuantumMachinesResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def close_all_quantum_machines(
        self,
        close_all_quantum_machines_request: "CloseAllQuantumMachinesRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "CloseAllQuantumMachinesResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.QmmService/CloseAllQuantumMachines",
            close_all_quantum_machines_request,
            CloseAllQuantumMachinesResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def clear_all_job_results(
        self,
        clear_all_job_results_request: "ClearAllJobResultsRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "ClearAllJobResultsResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.QmmService/ClearAllJobResults",
            clear_all_job_results_request,
            ClearAllJobResultsResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_jobs(
        self,
        get_jobs_request: "GetJobsRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetJobsResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.QmmService/GetJobs",
            get_jobs_request,
            GetJobsResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_job(
        self,
        get_job_request: "GetJobRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetJobResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.QmmService/GetJob",
            get_job_request,
            GetJobResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def reset_data_processing(
        self,
        qmm_service_reset_data_processing_request: "QmmServiceResetDataProcessingRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "ResetDataProcessingResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.QmmService/ResetDataProcessing",
            qmm_service_reset_data_processing_request,
            ResetDataProcessingResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def simulate(
        self,
        qmm_service_simulate_request: "QmmServiceSimulateRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "QmmServiceSimulateResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.QmmService/Simulate",
            qmm_service_simulate_request,
            QmmServiceSimulateResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )


class QmServiceStub(betterproto.ServiceStub):
    async def update_config(
        self,
        update_config_request: "UpdateConfigRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "UpdateConfigResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.QmService/UpdateConfig",
            update_config_request,
            UpdateConfigResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_config(
        self,
        qm_service_get_config_request: "QmServiceGetConfigRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "QmServiceGetConfigResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.QmService/GetConfig",
            qm_service_get_config_request,
            QmServiceGetConfigResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def compile(
        self,
        qm_service_compile_request: "QmServiceCompileRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "CompileResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.QmService/Compile",
            qm_service_compile_request,
            CompileResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def close(
        self,
        qm_service_close_request: "QmServiceCloseRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "QmServiceCloseResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.QmService/Close",
            qm_service_close_request,
            QmServiceCloseResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def execute(
        self,
        execute_request: "ExecuteRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "ExecuteResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.QmService/Execute",
            execute_request,
            ExecuteResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def add_to_queue(
        self,
        qm_service_add_to_queue_request: "QmServiceAddToQueueRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "AddToQueueResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.QmService/AddToQueue",
            qm_service_add_to_queue_request,
            AddToQueueResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def add_compiled_to_queue(
        self,
        qm_service_add_compiled_to_queue_request: "QmServiceAddCompiledToQueueRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "AddCompiledToQueueResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.QmService/AddCompiledToQueue",
            qm_service_add_compiled_to_queue_request,
            AddCompiledToQueueResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_jobs(
        self,
        qm_service_get_jobs_request: "QmServiceGetJobsRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "QmServiceGetJobsResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.QmService/GetJobs",
            qm_service_get_jobs_request,
            QmServiceGetJobsResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def remove_jobs(
        self,
        remove_jobs_request: "RemoveJobsRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "RemoveJobsResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.QmService/RemoveJobs",
            remove_jobs_request,
            RemoveJobsResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def simulate(
        self,
        qm_service_simulate_request: "QmServiceSimulateRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "QmServiceSimulateResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.QmService/Simulate",
            qm_service_simulate_request,
            QmServiceSimulateResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )


class JobServiceStub(betterproto.ServiceStub):
    async def get_config(
        self,
        job_service_get_config_request: "JobServiceGetConfigRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "JobServiceGetConfigResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.JobService/GetConfig",
            job_service_get_config_request,
            JobServiceGetConfigResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_job_status(
        self,
        job_service_get_job_status_request: "JobServiceGetJobStatusRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "JobServiceGetJobStatusResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.JobService/GetJobStatus",
            job_service_get_job_status_request,
            JobServiceGetJobStatusResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_job_status_updates(
        self,
        job_service_get_job_status_request: "JobServiceGetJobStatusRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> AsyncIterator[JobServiceGetJobStatusResponse]:
        async for response in self._unary_stream(
            "/qm.grpc.v2.JobService/GetJobStatusUpdates",
            job_service_get_job_status_request,
            JobServiceGetJobStatusResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        ):
            yield response

    async def push_to_input_stream(
        self,
        job_service_push_to_input_stream_request: "JobServicePushToInputStreamRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PushToInputStreamResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.JobService/PushToInputStream",
            job_service_push_to_input_stream_request,
            PushToInputStreamResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def is_paused(
        self,
        job_service_is_paused_request: "JobServiceIsPausedRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "IsPausedResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.JobService/IsPaused",
            job_service_is_paused_request,
            IsPausedResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def resume(
        self,
        resume_request: "ResumeRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "ResumeResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.JobService/Resume",
            resume_request,
            ResumeResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def set_matrix_correction(
        self,
        set_matrix_correction_request: "SetMatrixCorrectionRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "SetMatrixCorrectionResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.JobService/SetMatrixCorrection",
            set_matrix_correction_request,
            SetMatrixCorrectionResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_matrix_correction(
        self,
        get_matrix_correction_request: "GetMatrixCorrectionRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetMatrixCorrectionResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.JobService/GetMatrixCorrection",
            get_matrix_correction_request,
            GetMatrixCorrectionResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def set_intermediate_frequency(
        self,
        set_intermediate_frequency_request: "SetIntermediateFrequencyRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "SetIntermediateFrequencyResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.JobService/SetIntermediateFrequency",
            set_intermediate_frequency_request,
            SetIntermediateFrequencyResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_intermediate_frequency(
        self,
        get_intermediate_frequency_request: "GetIntermediateFrequencyRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetIntermediateFrequencyResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.JobService/GetIntermediateFrequency",
            get_intermediate_frequency_request,
            GetIntermediateFrequencyResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def set_digital_delay(
        self,
        set_digital_delay_request: "SetDigitalDelayRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "SetDigitalDelayResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.JobService/SetDigitalDelay",
            set_digital_delay_request,
            SetDigitalDelayResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_digital_delay(
        self,
        get_digital_delay_request: "GetDigitalDelayRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetDigitalDelayResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.JobService/GetDigitalDelay",
            get_digital_delay_request,
            GetDigitalDelayResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def set_digital_buffer(
        self,
        set_digital_buffer_request: "SetDigitalBufferRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "SetDigitalBufferResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.JobService/SetDigitalBuffer",
            set_digital_buffer_request,
            SetDigitalBufferResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_digital_buffer(
        self,
        get_digital_buffer_request: "GetDigitalBufferRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetDigitalBufferResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.JobService/GetDigitalBuffer",
            get_digital_buffer_request,
            GetDigitalBufferResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def set_input_dc_offset(
        self,
        set_input_dc_offset_request: "SetInputDcOffsetRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "SetInputDcOffsetResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.JobService/SetInputDcOffset",
            set_input_dc_offset_request,
            SetInputDcOffsetResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_input_dc_offset(
        self,
        get_input_dc_offset_request: "GetInputDcOffsetRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetInputDcOffsetResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.JobService/GetInputDcOffset",
            get_input_dc_offset_request,
            GetInputDcOffsetResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def set_output_dc_offset(
        self,
        set_output_dc_offset_request: "SetOutputDcOffsetRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "SetOutputDcOffsetResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.JobService/SetOutputDcOffset",
            set_output_dc_offset_request,
            SetOutputDcOffsetResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_output_dc_offset(
        self,
        get_output_dc_offset_request: "GetOutputDcOffsetRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetOutputDcOffsetResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.JobService/GetOutputDcOffset",
            get_output_dc_offset_request,
            GetOutputDcOffsetResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def set_oscillator_frequency(
        self,
        set_oscillator_frequency_request: "SetOscillatorFrequencyRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "SetOscillatorFrequencyResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.JobService/SetOscillatorFrequency",
            set_oscillator_frequency_request,
            SetOscillatorFrequencyResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def set_io_values(
        self,
        set_io_values_request: "SetIoValuesRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "SetIoValuesResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.JobService/SetIOValues",
            set_io_values_request,
            SetIoValuesResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_io_values(
        self,
        get_io_values_request: "GetIoValuesRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetIoValuesResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.JobService/GetIOValues",
            get_io_values_request,
            GetIoValuesResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_job_result_schema(
        self,
        get_job_result_schema_request: "GetJobResultSchemaRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetJobResultSchemaResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.JobService/GetJobResultSchema",
            get_job_result_schema_request,
            GetJobResultSchemaResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_job_named_result_header(
        self,
        get_job_named_result_header_request: "GetJobNamedResultHeaderRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetJobNamedResultHeaderResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.JobService/GetJobNamedResultHeader",
            get_job_named_result_header_request,
            GetJobNamedResultHeaderResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_named_result(
        self,
        get_named_result_request: "GetNamedResultRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> AsyncIterator[GetNamedResultResponse]:
        async for response in self._unary_stream(
            "/qm.grpc.v2.JobService/GetNamedResult",
            get_named_result_request,
            GetNamedResultResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        ):
            yield response

    async def get_errors(
        self,
        get_job_errors_request: "GetJobErrorsRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetJobErrorsResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.JobService/GetErrors",
            get_job_errors_request,
            GetJobErrorsResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_program_metadata(
        self,
        get_program_metadata_request: "GetProgramMetadataRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetProgramMetadataResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.JobService/GetProgramMetadata",
            get_program_metadata_request,
            GetProgramMetadataResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_job_result_state(
        self,
        get_job_result_state_request: "GetJobResultStateRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetJobResultStateResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.JobService/GetJobResultState",
            get_job_result_state_request,
            GetJobResultStateResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def pull_samples(
        self,
        pull_samples_request: "PullSamplesRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> AsyncIterator[PullSamplesResponse]:
        async for response in self._unary_stream(
            "/qm.grpc.v2.JobService/PullSamples",
            pull_samples_request,
            PullSamplesResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        ):
            yield response

    async def cancel(
        self,
        cancel_request: "CancelRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "CancelResponse":
        return await self._unary_unary(
            "/qm.grpc.v2.JobService/Cancel",
            cancel_request,
            CancelResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )


class QmmServiceBase(ServiceBase):
    async def get_version(
        self, get_version_request: "GetVersionRequest"
    ) -> "GetVersionResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def health_check(
        self, health_check_request: "HealthCheckRequest"
    ) -> "HealthCheckResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_controllers(
        self, get_controllers_request: "GetControllersRequest"
    ) -> "GetControllersResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def open_quantum_machine(
        self, open_quantum_machine_request: "OpenQuantumMachineRequest"
    ) -> "OpenQuantumMachineResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_quantum_machine(
        self,
        qmm_service_get_quantum_machine_request: "QmmServiceGetQuantumMachineRequest",
    ) -> "GetQuantumMachineResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def list_open_quantum_machines(
        self, list_open_quantum_machines_request: "ListOpenQuantumMachinesRequest"
    ) -> "ListOpenQuantumMachinesResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def close_all_quantum_machines(
        self, close_all_quantum_machines_request: "CloseAllQuantumMachinesRequest"
    ) -> "CloseAllQuantumMachinesResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def clear_all_job_results(
        self, clear_all_job_results_request: "ClearAllJobResultsRequest"
    ) -> "ClearAllJobResultsResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_jobs(self, get_jobs_request: "GetJobsRequest") -> "GetJobsResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_job(self, get_job_request: "GetJobRequest") -> "GetJobResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def reset_data_processing(
        self,
        qmm_service_reset_data_processing_request: "QmmServiceResetDataProcessingRequest",
    ) -> "ResetDataProcessingResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def simulate(
        self, qmm_service_simulate_request: "QmmServiceSimulateRequest"
    ) -> "QmmServiceSimulateResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def __rpc_get_version(
        self, stream: "grpclib.server.Stream[GetVersionRequest, GetVersionResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_version(request)
        await stream.send_message(response)

    async def __rpc_health_check(
        self, stream: "grpclib.server.Stream[HealthCheckRequest, HealthCheckResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.health_check(request)
        await stream.send_message(response)

    async def __rpc_get_controllers(
        self,
        stream: "grpclib.server.Stream[GetControllersRequest, GetControllersResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_controllers(request)
        await stream.send_message(response)

    async def __rpc_open_quantum_machine(
        self,
        stream: "grpclib.server.Stream[OpenQuantumMachineRequest, OpenQuantumMachineResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.open_quantum_machine(request)
        await stream.send_message(response)

    async def __rpc_get_quantum_machine(
        self,
        stream: "grpclib.server.Stream[QmmServiceGetQuantumMachineRequest, GetQuantumMachineResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_quantum_machine(request)
        await stream.send_message(response)

    async def __rpc_list_open_quantum_machines(
        self,
        stream: "grpclib.server.Stream[ListOpenQuantumMachinesRequest, ListOpenQuantumMachinesResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.list_open_quantum_machines(request)
        await stream.send_message(response)

    async def __rpc_close_all_quantum_machines(
        self,
        stream: "grpclib.server.Stream[CloseAllQuantumMachinesRequest, CloseAllQuantumMachinesResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.close_all_quantum_machines(request)
        await stream.send_message(response)

    async def __rpc_clear_all_job_results(
        self,
        stream: "grpclib.server.Stream[ClearAllJobResultsRequest, ClearAllJobResultsResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.clear_all_job_results(request)
        await stream.send_message(response)

    async def __rpc_get_jobs(
        self, stream: "grpclib.server.Stream[GetJobsRequest, GetJobsResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_jobs(request)
        await stream.send_message(response)

    async def __rpc_get_job(
        self, stream: "grpclib.server.Stream[GetJobRequest, GetJobResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_job(request)
        await stream.send_message(response)

    async def __rpc_reset_data_processing(
        self,
        stream: "grpclib.server.Stream[QmmServiceResetDataProcessingRequest, ResetDataProcessingResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.reset_data_processing(request)
        await stream.send_message(response)

    async def __rpc_simulate(
        self,
        stream: "grpclib.server.Stream[QmmServiceSimulateRequest, QmmServiceSimulateResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.simulate(request)
        await stream.send_message(response)

    def __mapping__(self) -> Dict[str, grpclib.const.Handler]:
        return {
            "/qm.grpc.v2.QmmService/GetVersion": grpclib.const.Handler(
                self.__rpc_get_version,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetVersionRequest,
                GetVersionResponse,
            ),
            "/qm.grpc.v2.QmmService/HealthCheck": grpclib.const.Handler(
                self.__rpc_health_check,
                grpclib.const.Cardinality.UNARY_UNARY,
                HealthCheckRequest,
                HealthCheckResponse,
            ),
            "/qm.grpc.v2.QmmService/GetControllers": grpclib.const.Handler(
                self.__rpc_get_controllers,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetControllersRequest,
                GetControllersResponse,
            ),
            "/qm.grpc.v2.QmmService/OpenQuantumMachine": grpclib.const.Handler(
                self.__rpc_open_quantum_machine,
                grpclib.const.Cardinality.UNARY_UNARY,
                OpenQuantumMachineRequest,
                OpenQuantumMachineResponse,
            ),
            "/qm.grpc.v2.QmmService/GetQuantumMachine": grpclib.const.Handler(
                self.__rpc_get_quantum_machine,
                grpclib.const.Cardinality.UNARY_UNARY,
                QmmServiceGetQuantumMachineRequest,
                GetQuantumMachineResponse,
            ),
            "/qm.grpc.v2.QmmService/ListOpenQuantumMachines": grpclib.const.Handler(
                self.__rpc_list_open_quantum_machines,
                grpclib.const.Cardinality.UNARY_UNARY,
                ListOpenQuantumMachinesRequest,
                ListOpenQuantumMachinesResponse,
            ),
            "/qm.grpc.v2.QmmService/CloseAllQuantumMachines": grpclib.const.Handler(
                self.__rpc_close_all_quantum_machines,
                grpclib.const.Cardinality.UNARY_UNARY,
                CloseAllQuantumMachinesRequest,
                CloseAllQuantumMachinesResponse,
            ),
            "/qm.grpc.v2.QmmService/ClearAllJobResults": grpclib.const.Handler(
                self.__rpc_clear_all_job_results,
                grpclib.const.Cardinality.UNARY_UNARY,
                ClearAllJobResultsRequest,
                ClearAllJobResultsResponse,
            ),
            "/qm.grpc.v2.QmmService/GetJobs": grpclib.const.Handler(
                self.__rpc_get_jobs,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetJobsRequest,
                GetJobsResponse,
            ),
            "/qm.grpc.v2.QmmService/GetJob": grpclib.const.Handler(
                self.__rpc_get_job,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetJobRequest,
                GetJobResponse,
            ),
            "/qm.grpc.v2.QmmService/ResetDataProcessing": grpclib.const.Handler(
                self.__rpc_reset_data_processing,
                grpclib.const.Cardinality.UNARY_UNARY,
                QmmServiceResetDataProcessingRequest,
                ResetDataProcessingResponse,
            ),
            "/qm.grpc.v2.QmmService/Simulate": grpclib.const.Handler(
                self.__rpc_simulate,
                grpclib.const.Cardinality.UNARY_UNARY,
                QmmServiceSimulateRequest,
                QmmServiceSimulateResponse,
            ),
        }


class QmServiceBase(ServiceBase):
    async def update_config(
        self, update_config_request: "UpdateConfigRequest"
    ) -> "UpdateConfigResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_config(
        self, qm_service_get_config_request: "QmServiceGetConfigRequest"
    ) -> "QmServiceGetConfigResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def compile(
        self, qm_service_compile_request: "QmServiceCompileRequest"
    ) -> "CompileResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def close(
        self, qm_service_close_request: "QmServiceCloseRequest"
    ) -> "QmServiceCloseResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def execute(self, execute_request: "ExecuteRequest") -> "ExecuteResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def add_to_queue(
        self, qm_service_add_to_queue_request: "QmServiceAddToQueueRequest"
    ) -> "AddToQueueResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def add_compiled_to_queue(
        self,
        qm_service_add_compiled_to_queue_request: "QmServiceAddCompiledToQueueRequest",
    ) -> "AddCompiledToQueueResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_jobs(
        self, qm_service_get_jobs_request: "QmServiceGetJobsRequest"
    ) -> "QmServiceGetJobsResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def remove_jobs(
        self, remove_jobs_request: "RemoveJobsRequest"
    ) -> "RemoveJobsResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def simulate(
        self, qm_service_simulate_request: "QmServiceSimulateRequest"
    ) -> "QmServiceSimulateResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def __rpc_update_config(
        self, stream: "grpclib.server.Stream[UpdateConfigRequest, UpdateConfigResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.update_config(request)
        await stream.send_message(response)

    async def __rpc_get_config(
        self,
        stream: "grpclib.server.Stream[QmServiceGetConfigRequest, QmServiceGetConfigResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_config(request)
        await stream.send_message(response)

    async def __rpc_compile(
        self, stream: "grpclib.server.Stream[QmServiceCompileRequest, CompileResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.compile(request)
        await stream.send_message(response)

    async def __rpc_close(
        self,
        stream: "grpclib.server.Stream[QmServiceCloseRequest, QmServiceCloseResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.close(request)
        await stream.send_message(response)

    async def __rpc_execute(
        self, stream: "grpclib.server.Stream[ExecuteRequest, ExecuteResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.execute(request)
        await stream.send_message(response)

    async def __rpc_add_to_queue(
        self,
        stream: "grpclib.server.Stream[QmServiceAddToQueueRequest, AddToQueueResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.add_to_queue(request)
        await stream.send_message(response)

    async def __rpc_add_compiled_to_queue(
        self,
        stream: "grpclib.server.Stream[QmServiceAddCompiledToQueueRequest, AddCompiledToQueueResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.add_compiled_to_queue(request)
        await stream.send_message(response)

    async def __rpc_get_jobs(
        self,
        stream: "grpclib.server.Stream[QmServiceGetJobsRequest, QmServiceGetJobsResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_jobs(request)
        await stream.send_message(response)

    async def __rpc_remove_jobs(
        self, stream: "grpclib.server.Stream[RemoveJobsRequest, RemoveJobsResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.remove_jobs(request)
        await stream.send_message(response)

    async def __rpc_simulate(
        self,
        stream: "grpclib.server.Stream[QmServiceSimulateRequest, QmServiceSimulateResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.simulate(request)
        await stream.send_message(response)

    def __mapping__(self) -> Dict[str, grpclib.const.Handler]:
        return {
            "/qm.grpc.v2.QmService/UpdateConfig": grpclib.const.Handler(
                self.__rpc_update_config,
                grpclib.const.Cardinality.UNARY_UNARY,
                UpdateConfigRequest,
                UpdateConfigResponse,
            ),
            "/qm.grpc.v2.QmService/GetConfig": grpclib.const.Handler(
                self.__rpc_get_config,
                grpclib.const.Cardinality.UNARY_UNARY,
                QmServiceGetConfigRequest,
                QmServiceGetConfigResponse,
            ),
            "/qm.grpc.v2.QmService/Compile": grpclib.const.Handler(
                self.__rpc_compile,
                grpclib.const.Cardinality.UNARY_UNARY,
                QmServiceCompileRequest,
                CompileResponse,
            ),
            "/qm.grpc.v2.QmService/Close": grpclib.const.Handler(
                self.__rpc_close,
                grpclib.const.Cardinality.UNARY_UNARY,
                QmServiceCloseRequest,
                QmServiceCloseResponse,
            ),
            "/qm.grpc.v2.QmService/Execute": grpclib.const.Handler(
                self.__rpc_execute,
                grpclib.const.Cardinality.UNARY_UNARY,
                ExecuteRequest,
                ExecuteResponse,
            ),
            "/qm.grpc.v2.QmService/AddToQueue": grpclib.const.Handler(
                self.__rpc_add_to_queue,
                grpclib.const.Cardinality.UNARY_UNARY,
                QmServiceAddToQueueRequest,
                AddToQueueResponse,
            ),
            "/qm.grpc.v2.QmService/AddCompiledToQueue": grpclib.const.Handler(
                self.__rpc_add_compiled_to_queue,
                grpclib.const.Cardinality.UNARY_UNARY,
                QmServiceAddCompiledToQueueRequest,
                AddCompiledToQueueResponse,
            ),
            "/qm.grpc.v2.QmService/GetJobs": grpclib.const.Handler(
                self.__rpc_get_jobs,
                grpclib.const.Cardinality.UNARY_UNARY,
                QmServiceGetJobsRequest,
                QmServiceGetJobsResponse,
            ),
            "/qm.grpc.v2.QmService/RemoveJobs": grpclib.const.Handler(
                self.__rpc_remove_jobs,
                grpclib.const.Cardinality.UNARY_UNARY,
                RemoveJobsRequest,
                RemoveJobsResponse,
            ),
            "/qm.grpc.v2.QmService/Simulate": grpclib.const.Handler(
                self.__rpc_simulate,
                grpclib.const.Cardinality.UNARY_UNARY,
                QmServiceSimulateRequest,
                QmServiceSimulateResponse,
            ),
        }


class JobServiceBase(ServiceBase):
    async def get_config(
        self, job_service_get_config_request: "JobServiceGetConfigRequest"
    ) -> "JobServiceGetConfigResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_job_status(
        self, job_service_get_job_status_request: "JobServiceGetJobStatusRequest"
    ) -> "JobServiceGetJobStatusResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_job_status_updates(
        self, job_service_get_job_status_request: "JobServiceGetJobStatusRequest"
    ) -> AsyncIterator[JobServiceGetJobStatusResponse]:
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
        yield JobServiceGetJobStatusResponse()

    async def push_to_input_stream(
        self,
        job_service_push_to_input_stream_request: "JobServicePushToInputStreamRequest",
    ) -> "PushToInputStreamResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def is_paused(
        self, job_service_is_paused_request: "JobServiceIsPausedRequest"
    ) -> "IsPausedResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def resume(self, resume_request: "ResumeRequest") -> "ResumeResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def set_matrix_correction(
        self, set_matrix_correction_request: "SetMatrixCorrectionRequest"
    ) -> "SetMatrixCorrectionResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_matrix_correction(
        self, get_matrix_correction_request: "GetMatrixCorrectionRequest"
    ) -> "GetMatrixCorrectionResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def set_intermediate_frequency(
        self, set_intermediate_frequency_request: "SetIntermediateFrequencyRequest"
    ) -> "SetIntermediateFrequencyResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_intermediate_frequency(
        self, get_intermediate_frequency_request: "GetIntermediateFrequencyRequest"
    ) -> "GetIntermediateFrequencyResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def set_digital_delay(
        self, set_digital_delay_request: "SetDigitalDelayRequest"
    ) -> "SetDigitalDelayResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_digital_delay(
        self, get_digital_delay_request: "GetDigitalDelayRequest"
    ) -> "GetDigitalDelayResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def set_digital_buffer(
        self, set_digital_buffer_request: "SetDigitalBufferRequest"
    ) -> "SetDigitalBufferResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_digital_buffer(
        self, get_digital_buffer_request: "GetDigitalBufferRequest"
    ) -> "GetDigitalBufferResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def set_input_dc_offset(
        self, set_input_dc_offset_request: "SetInputDcOffsetRequest"
    ) -> "SetInputDcOffsetResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_input_dc_offset(
        self, get_input_dc_offset_request: "GetInputDcOffsetRequest"
    ) -> "GetInputDcOffsetResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def set_output_dc_offset(
        self, set_output_dc_offset_request: "SetOutputDcOffsetRequest"
    ) -> "SetOutputDcOffsetResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_output_dc_offset(
        self, get_output_dc_offset_request: "GetOutputDcOffsetRequest"
    ) -> "GetOutputDcOffsetResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def set_oscillator_frequency(
        self, set_oscillator_frequency_request: "SetOscillatorFrequencyRequest"
    ) -> "SetOscillatorFrequencyResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def set_io_values(
        self, set_io_values_request: "SetIoValuesRequest"
    ) -> "SetIoValuesResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_io_values(
        self, get_io_values_request: "GetIoValuesRequest"
    ) -> "GetIoValuesResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_job_result_schema(
        self, get_job_result_schema_request: "GetJobResultSchemaRequest"
    ) -> "GetJobResultSchemaResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_job_named_result_header(
        self, get_job_named_result_header_request: "GetJobNamedResultHeaderRequest"
    ) -> "GetJobNamedResultHeaderResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_named_result(
        self, get_named_result_request: "GetNamedResultRequest"
    ) -> AsyncIterator[GetNamedResultResponse]:
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
        yield GetNamedResultResponse()

    async def get_errors(
        self, get_job_errors_request: "GetJobErrorsRequest"
    ) -> "GetJobErrorsResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_program_metadata(
        self, get_program_metadata_request: "GetProgramMetadataRequest"
    ) -> "GetProgramMetadataResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_job_result_state(
        self, get_job_result_state_request: "GetJobResultStateRequest"
    ) -> "GetJobResultStateResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def pull_samples(
        self, pull_samples_request: "PullSamplesRequest"
    ) -> AsyncIterator[PullSamplesResponse]:
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
        yield PullSamplesResponse()

    async def cancel(self, cancel_request: "CancelRequest") -> "CancelResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def __rpc_get_config(
        self,
        stream: "grpclib.server.Stream[JobServiceGetConfigRequest, JobServiceGetConfigResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_config(request)
        await stream.send_message(response)

    async def __rpc_get_job_status(
        self,
        stream: "grpclib.server.Stream[JobServiceGetJobStatusRequest, JobServiceGetJobStatusResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_job_status(request)
        await stream.send_message(response)

    async def __rpc_get_job_status_updates(
        self,
        stream: "grpclib.server.Stream[JobServiceGetJobStatusRequest, JobServiceGetJobStatusResponse]",
    ) -> None:
        request = await stream.recv_message()
        await self._call_rpc_handler_server_stream(
            self.get_job_status_updates,
            stream,
            request,
        )

    async def __rpc_push_to_input_stream(
        self,
        stream: "grpclib.server.Stream[JobServicePushToInputStreamRequest, PushToInputStreamResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.push_to_input_stream(request)
        await stream.send_message(response)

    async def __rpc_is_paused(
        self,
        stream: "grpclib.server.Stream[JobServiceIsPausedRequest, IsPausedResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.is_paused(request)
        await stream.send_message(response)

    async def __rpc_resume(
        self, stream: "grpclib.server.Stream[ResumeRequest, ResumeResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.resume(request)
        await stream.send_message(response)

    async def __rpc_set_matrix_correction(
        self,
        stream: "grpclib.server.Stream[SetMatrixCorrectionRequest, SetMatrixCorrectionResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.set_matrix_correction(request)
        await stream.send_message(response)

    async def __rpc_get_matrix_correction(
        self,
        stream: "grpclib.server.Stream[GetMatrixCorrectionRequest, GetMatrixCorrectionResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_matrix_correction(request)
        await stream.send_message(response)

    async def __rpc_set_intermediate_frequency(
        self,
        stream: "grpclib.server.Stream[SetIntermediateFrequencyRequest, SetIntermediateFrequencyResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.set_intermediate_frequency(request)
        await stream.send_message(response)

    async def __rpc_get_intermediate_frequency(
        self,
        stream: "grpclib.server.Stream[GetIntermediateFrequencyRequest, GetIntermediateFrequencyResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_intermediate_frequency(request)
        await stream.send_message(response)

    async def __rpc_set_digital_delay(
        self,
        stream: "grpclib.server.Stream[SetDigitalDelayRequest, SetDigitalDelayResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.set_digital_delay(request)
        await stream.send_message(response)

    async def __rpc_get_digital_delay(
        self,
        stream: "grpclib.server.Stream[GetDigitalDelayRequest, GetDigitalDelayResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_digital_delay(request)
        await stream.send_message(response)

    async def __rpc_set_digital_buffer(
        self,
        stream: "grpclib.server.Stream[SetDigitalBufferRequest, SetDigitalBufferResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.set_digital_buffer(request)
        await stream.send_message(response)

    async def __rpc_get_digital_buffer(
        self,
        stream: "grpclib.server.Stream[GetDigitalBufferRequest, GetDigitalBufferResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_digital_buffer(request)
        await stream.send_message(response)

    async def __rpc_set_input_dc_offset(
        self,
        stream: "grpclib.server.Stream[SetInputDcOffsetRequest, SetInputDcOffsetResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.set_input_dc_offset(request)
        await stream.send_message(response)

    async def __rpc_get_input_dc_offset(
        self,
        stream: "grpclib.server.Stream[GetInputDcOffsetRequest, GetInputDcOffsetResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_input_dc_offset(request)
        await stream.send_message(response)

    async def __rpc_set_output_dc_offset(
        self,
        stream: "grpclib.server.Stream[SetOutputDcOffsetRequest, SetOutputDcOffsetResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.set_output_dc_offset(request)
        await stream.send_message(response)

    async def __rpc_get_output_dc_offset(
        self,
        stream: "grpclib.server.Stream[GetOutputDcOffsetRequest, GetOutputDcOffsetResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_output_dc_offset(request)
        await stream.send_message(response)

    async def __rpc_set_oscillator_frequency(
        self,
        stream: "grpclib.server.Stream[SetOscillatorFrequencyRequest, SetOscillatorFrequencyResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.set_oscillator_frequency(request)
        await stream.send_message(response)

    async def __rpc_set_io_values(
        self, stream: "grpclib.server.Stream[SetIoValuesRequest, SetIoValuesResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.set_io_values(request)
        await stream.send_message(response)

    async def __rpc_get_io_values(
        self, stream: "grpclib.server.Stream[GetIoValuesRequest, GetIoValuesResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_io_values(request)
        await stream.send_message(response)

    async def __rpc_get_job_result_schema(
        self,
        stream: "grpclib.server.Stream[GetJobResultSchemaRequest, GetJobResultSchemaResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_job_result_schema(request)
        await stream.send_message(response)

    async def __rpc_get_job_named_result_header(
        self,
        stream: "grpclib.server.Stream[GetJobNamedResultHeaderRequest, GetJobNamedResultHeaderResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_job_named_result_header(request)
        await stream.send_message(response)

    async def __rpc_get_named_result(
        self,
        stream: "grpclib.server.Stream[GetNamedResultRequest, GetNamedResultResponse]",
    ) -> None:
        request = await stream.recv_message()
        await self._call_rpc_handler_server_stream(
            self.get_named_result,
            stream,
            request,
        )

    async def __rpc_get_errors(
        self, stream: "grpclib.server.Stream[GetJobErrorsRequest, GetJobErrorsResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_errors(request)
        await stream.send_message(response)

    async def __rpc_get_program_metadata(
        self,
        stream: "grpclib.server.Stream[GetProgramMetadataRequest, GetProgramMetadataResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_program_metadata(request)
        await stream.send_message(response)

    async def __rpc_get_job_result_state(
        self,
        stream: "grpclib.server.Stream[GetJobResultStateRequest, GetJobResultStateResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_job_result_state(request)
        await stream.send_message(response)

    async def __rpc_pull_samples(
        self, stream: "grpclib.server.Stream[PullSamplesRequest, PullSamplesResponse]"
    ) -> None:
        request = await stream.recv_message()
        await self._call_rpc_handler_server_stream(
            self.pull_samples,
            stream,
            request,
        )

    async def __rpc_cancel(
        self, stream: "grpclib.server.Stream[CancelRequest, CancelResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.cancel(request)
        await stream.send_message(response)

    def __mapping__(self) -> Dict[str, grpclib.const.Handler]:
        return {
            "/qm.grpc.v2.JobService/GetConfig": grpclib.const.Handler(
                self.__rpc_get_config,
                grpclib.const.Cardinality.UNARY_UNARY,
                JobServiceGetConfigRequest,
                JobServiceGetConfigResponse,
            ),
            "/qm.grpc.v2.JobService/GetJobStatus": grpclib.const.Handler(
                self.__rpc_get_job_status,
                grpclib.const.Cardinality.UNARY_UNARY,
                JobServiceGetJobStatusRequest,
                JobServiceGetJobStatusResponse,
            ),
            "/qm.grpc.v2.JobService/GetJobStatusUpdates": grpclib.const.Handler(
                self.__rpc_get_job_status_updates,
                grpclib.const.Cardinality.UNARY_STREAM,
                JobServiceGetJobStatusRequest,
                JobServiceGetJobStatusResponse,
            ),
            "/qm.grpc.v2.JobService/PushToInputStream": grpclib.const.Handler(
                self.__rpc_push_to_input_stream,
                grpclib.const.Cardinality.UNARY_UNARY,
                JobServicePushToInputStreamRequest,
                PushToInputStreamResponse,
            ),
            "/qm.grpc.v2.JobService/IsPaused": grpclib.const.Handler(
                self.__rpc_is_paused,
                grpclib.const.Cardinality.UNARY_UNARY,
                JobServiceIsPausedRequest,
                IsPausedResponse,
            ),
            "/qm.grpc.v2.JobService/Resume": grpclib.const.Handler(
                self.__rpc_resume,
                grpclib.const.Cardinality.UNARY_UNARY,
                ResumeRequest,
                ResumeResponse,
            ),
            "/qm.grpc.v2.JobService/SetMatrixCorrection": grpclib.const.Handler(
                self.__rpc_set_matrix_correction,
                grpclib.const.Cardinality.UNARY_UNARY,
                SetMatrixCorrectionRequest,
                SetMatrixCorrectionResponse,
            ),
            "/qm.grpc.v2.JobService/GetMatrixCorrection": grpclib.const.Handler(
                self.__rpc_get_matrix_correction,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetMatrixCorrectionRequest,
                GetMatrixCorrectionResponse,
            ),
            "/qm.grpc.v2.JobService/SetIntermediateFrequency": grpclib.const.Handler(
                self.__rpc_set_intermediate_frequency,
                grpclib.const.Cardinality.UNARY_UNARY,
                SetIntermediateFrequencyRequest,
                SetIntermediateFrequencyResponse,
            ),
            "/qm.grpc.v2.JobService/GetIntermediateFrequency": grpclib.const.Handler(
                self.__rpc_get_intermediate_frequency,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetIntermediateFrequencyRequest,
                GetIntermediateFrequencyResponse,
            ),
            "/qm.grpc.v2.JobService/SetDigitalDelay": grpclib.const.Handler(
                self.__rpc_set_digital_delay,
                grpclib.const.Cardinality.UNARY_UNARY,
                SetDigitalDelayRequest,
                SetDigitalDelayResponse,
            ),
            "/qm.grpc.v2.JobService/GetDigitalDelay": grpclib.const.Handler(
                self.__rpc_get_digital_delay,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetDigitalDelayRequest,
                GetDigitalDelayResponse,
            ),
            "/qm.grpc.v2.JobService/SetDigitalBuffer": grpclib.const.Handler(
                self.__rpc_set_digital_buffer,
                grpclib.const.Cardinality.UNARY_UNARY,
                SetDigitalBufferRequest,
                SetDigitalBufferResponse,
            ),
            "/qm.grpc.v2.JobService/GetDigitalBuffer": grpclib.const.Handler(
                self.__rpc_get_digital_buffer,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetDigitalBufferRequest,
                GetDigitalBufferResponse,
            ),
            "/qm.grpc.v2.JobService/SetInputDcOffset": grpclib.const.Handler(
                self.__rpc_set_input_dc_offset,
                grpclib.const.Cardinality.UNARY_UNARY,
                SetInputDcOffsetRequest,
                SetInputDcOffsetResponse,
            ),
            "/qm.grpc.v2.JobService/GetInputDcOffset": grpclib.const.Handler(
                self.__rpc_get_input_dc_offset,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetInputDcOffsetRequest,
                GetInputDcOffsetResponse,
            ),
            "/qm.grpc.v2.JobService/SetOutputDcOffset": grpclib.const.Handler(
                self.__rpc_set_output_dc_offset,
                grpclib.const.Cardinality.UNARY_UNARY,
                SetOutputDcOffsetRequest,
                SetOutputDcOffsetResponse,
            ),
            "/qm.grpc.v2.JobService/GetOutputDcOffset": grpclib.const.Handler(
                self.__rpc_get_output_dc_offset,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetOutputDcOffsetRequest,
                GetOutputDcOffsetResponse,
            ),
            "/qm.grpc.v2.JobService/SetOscillatorFrequency": grpclib.const.Handler(
                self.__rpc_set_oscillator_frequency,
                grpclib.const.Cardinality.UNARY_UNARY,
                SetOscillatorFrequencyRequest,
                SetOscillatorFrequencyResponse,
            ),
            "/qm.grpc.v2.JobService/SetIOValues": grpclib.const.Handler(
                self.__rpc_set_io_values,
                grpclib.const.Cardinality.UNARY_UNARY,
                SetIoValuesRequest,
                SetIoValuesResponse,
            ),
            "/qm.grpc.v2.JobService/GetIOValues": grpclib.const.Handler(
                self.__rpc_get_io_values,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetIoValuesRequest,
                GetIoValuesResponse,
            ),
            "/qm.grpc.v2.JobService/GetJobResultSchema": grpclib.const.Handler(
                self.__rpc_get_job_result_schema,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetJobResultSchemaRequest,
                GetJobResultSchemaResponse,
            ),
            "/qm.grpc.v2.JobService/GetJobNamedResultHeader": grpclib.const.Handler(
                self.__rpc_get_job_named_result_header,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetJobNamedResultHeaderRequest,
                GetJobNamedResultHeaderResponse,
            ),
            "/qm.grpc.v2.JobService/GetNamedResult": grpclib.const.Handler(
                self.__rpc_get_named_result,
                grpclib.const.Cardinality.UNARY_STREAM,
                GetNamedResultRequest,
                GetNamedResultResponse,
            ),
            "/qm.grpc.v2.JobService/GetErrors": grpclib.const.Handler(
                self.__rpc_get_errors,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetJobErrorsRequest,
                GetJobErrorsResponse,
            ),
            "/qm.grpc.v2.JobService/GetProgramMetadata": grpclib.const.Handler(
                self.__rpc_get_program_metadata,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetProgramMetadataRequest,
                GetProgramMetadataResponse,
            ),
            "/qm.grpc.v2.JobService/GetJobResultState": grpclib.const.Handler(
                self.__rpc_get_job_result_state,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetJobResultStateRequest,
                GetJobResultStateResponse,
            ),
            "/qm.grpc.v2.JobService/PullSamples": grpclib.const.Handler(
                self.__rpc_pull_samples,
                grpclib.const.Cardinality.UNARY_STREAM,
                PullSamplesRequest,
                PullSamplesResponse,
            ),
            "/qm.grpc.v2.JobService/Cancel": grpclib.const.Handler(
                self.__rpc_cancel,
                grpclib.const.Cardinality.UNARY_UNARY,
                CancelRequest,
                CancelResponse,
            ),
        }
