# Generated by the protocol buffer compiler.  DO NOT EDIT!
# sources: qm/pb/frontend.proto
# plugin: python-betterproto
# This file has been @generated
import warnings
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__,
    general_messages as _general_messages__,
    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 IsJobAcquiringDataResponseAcquiringStatus(betterproto.Enum):
    ACQUIRE_STOPPED = 0
    NO_DATA_TO_ACQUIRE = 1
    HAS_DATA_TO_ACQUIRE = 2


@dataclass(eq=False, repr=False)
class QueuePosition(betterproto.Message):
    end: "betterproto_lib_google_protobuf.Empty" = betterproto.message_field(
        1, group="position"
    )
    start: "betterproto_lib_google_protobuf.Empty" = betterproto.message_field(
        2, group="position"
    )


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


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


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


@dataclass(eq=False, repr=False)
class ExecutionOverrides(betterproto.Message):
    waveforms: Dict[str, "WaveformOverride"] = betterproto.map_field(
        1, betterproto.TYPE_STRING, betterproto.TYPE_MESSAGE
    )


@dataclass(eq=False, repr=False)
class AddCompiledToQueueRequest(betterproto.Message):
    quantum_machine_id: str = betterproto.string_field(1)
    program_id: str = betterproto.string_field(2)
    queue_position: "QueuePosition" = betterproto.message_field(3)
    execution_overrides: "ExecutionOverrides" = betterproto.message_field(4)


@dataclass(eq=False, repr=False)
class AddCompiledToQueueResponse(betterproto.Message):
    ok: bool = betterproto.bool_field(1)
    job_id: str = betterproto.string_field(2)
    errors: List["_general_messages__.ErrorMessage"] = betterproto.message_field(3)


@dataclass(eq=False, repr=False)
class CompileRequest(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):
    ok: bool = betterproto.bool_field(1)
    program_id: str = betterproto.string_field(2)
    messages: List["_compiler__.CompilerMessage"] = betterproto.message_field(3)


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


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


@dataclass(eq=False, repr=False)
class JobExecutionStatus(betterproto.Message):
    unknown: "JobExecutionStatusUnknown" = betterproto.message_field(1, group="status")
    pending: "JobExecutionStatusPending" = betterproto.message_field(2, group="status")
    running: "JobExecutionStatusRunning" = betterproto.message_field(3, group="status")
    completed: "JobExecutionStatusCompleted" = betterproto.message_field(
        4, group="status"
    )
    canceled: "JobExecutionStatusCanceled" = betterproto.message_field(
        5, group="status"
    )
    loading: "JobExecutionStatusLoading" = betterproto.message_field(6, group="status")
    error: "JobExecutionStatusError" = betterproto.message_field(7, group="status")
    processing: "JobExecutionStatusProcessing" = betterproto.message_field(
        8, group="status"
    )


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


@dataclass(eq=False, repr=False)
class JobExecutionStatusPending(betterproto.Message):
    position_in_queue: int = betterproto.int32_field(1)
    time_added: datetime = betterproto.message_field(2)
    added_by: str = betterproto.string_field(3)


@dataclass(eq=False, repr=False)
class JobExecutionStatusRunning(betterproto.Message):
    time_added: datetime = betterproto.message_field(1)
    added_by: str = betterproto.string_field(2)
    time_started: datetime = betterproto.message_field(3)


@dataclass(eq=False, repr=False)
class JobExecutionStatusCompleted(betterproto.Message):
    time_added: datetime = betterproto.message_field(1)
    added_by: str = betterproto.string_field(2)
    time_started: datetime = betterproto.message_field(3)
    time_completed: datetime = betterproto.message_field(4)


@dataclass(eq=False, repr=False)
class JobExecutionStatusCanceled(betterproto.Message):
    time_added: datetime = betterproto.message_field(1)
    added_by: str = betterproto.string_field(2)
    time_canceled: datetime = betterproto.message_field(3)


@dataclass(eq=False, repr=False)
class JobExecutionStatusLoading(betterproto.Message):
    time_added: datetime = betterproto.message_field(1)
    added_by: str = betterproto.string_field(2)


@dataclass(eq=False, repr=False)
class JobExecutionStatusError(betterproto.Message):
    error_messages: "betterproto_lib_google_protobuf.ListValue" = (
        betterproto.message_field(1)
    )
    added_by: str = betterproto.string_field(2)


@dataclass(eq=False, repr=False)
class JobExecutionStatusProcessing(betterproto.Message):
    time_added: datetime = betterproto.message_field(1)
    added_by: str = betterproto.string_field(2)
    time_started: datetime = betterproto.message_field(3)


@dataclass(eq=False, repr=False)
class GetPendingJobsResponse(betterproto.Message):
    pending_jobs: Dict[str, "JobExecutionStatusPending"] = betterproto.map_field(
        1, betterproto.TYPE_STRING, betterproto.TYPE_MESSAGE
    )


@dataclass(eq=False, repr=False)
class JobQueryParams(betterproto.Message):
    quantum_machine_id: str = betterproto.string_field(1)
    job_id: "QueryValueMatcher" = betterproto.message_field(2)
    user_id: "QueryValueMatcher" = betterproto.message_field(3)
    position: Optional[int] = betterproto.message_field(
        4, wraps=betterproto.TYPE_UINT32
    )


@dataclass(eq=False, repr=False)
class QueryValueMatcher(betterproto.Message):
    any: bool = betterproto.bool_field(1, group="valueType")
    value: str = betterproto.string_field(2, group="valueType")


@dataclass(eq=False, repr=False)
class RemovePendingJobsResponse(betterproto.Message):
    numbers_of_jobs_removed: int = betterproto.int32_field(1)


@dataclass(eq=False, repr=False)
class SimulationRequest(betterproto.Message):
    config: "_qua_config__.QuaConfig" = betterproto.message_field(1)
    high_level_program: "_qua__.QuaProgram" = betterproto.message_field(2)
    simulate: "ExecutionRequestSimulate" = betterproto.message_field(3)
    """The duration to simulate and provide results for"""

    controller_connections: List["InterOpxConnection"] = betterproto.message_field(6)


@dataclass(eq=False, repr=False)
class InterOpxAddress(betterproto.Message):
    controller: str = betterproto.string_field(1)
    left: bool = betterproto.bool_field(2)


@dataclass(eq=False, repr=False)
class InterOpxTarget(betterproto.Message):
    direct: "InterOpxAddress" = betterproto.message_field(1, group="target")


@dataclass(eq=False, repr=False)
class InterOpxChannel(betterproto.Message):
    controller: str = betterproto.string_field(1)
    channel_number: int = betterproto.int32_field(2)


@dataclass(eq=False, repr=False)
class InterOpxConnection(betterproto.Message):
    source: "InterOpxAddress" = betterproto.message_field(1)
    target: "InterOpxTarget" = betterproto.message_field(2)
    address_to_address: "InterOpxConnectionAddressToAddress" = (
        betterproto.message_field(3, group="connectionType")
    )
    channel_to_channel: "InterOpxConnectionChannelToChannel" = (
        betterproto.message_field(4, group="connectionType")
    )

    def __post_init__(self) -> None:
        super().__post_init__()
        if self.is_set("source"):
            warnings.warn("InterOpxConnection.source is deprecated", DeprecationWarning)
        if self.is_set("target"):
            warnings.warn("InterOpxConnection.target is deprecated", DeprecationWarning)


@dataclass(eq=False, repr=False)
class InterOpxConnectionAddressToAddress(betterproto.Message):
    source: "InterOpxAddress" = betterproto.message_field(1)
    target: "InterOpxAddress" = betterproto.message_field(2)


@dataclass(eq=False, repr=False)
class InterOpxConnectionChannelToChannel(betterproto.Message):
    source: "InterOpxChannel" = betterproto.message_field(1)
    target: "InterOpxChannel" = betterproto.message_field(2)


@dataclass(eq=False, repr=False)
class SimulationResponse(betterproto.Message):
    success: bool = betterproto.bool_field(1)
    job_id: str = betterproto.string_field(2)
    config_validation_errors: List[
        "_qm_manager__.ConfigValidationMessage"
    ] = betterproto.message_field(3)
    physical_validation_errors: List[
        "_qm_manager__.PhysicalValidationMessage"
    ] = betterproto.message_field(4)
    messages: List["_compiler__.CompilerMessage"] = betterproto.message_field(5)
    simulated: "SimulatedResponsePart" = betterproto.message_field(6)


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


@dataclass(eq=False, repr=False)
class IsJobRunningResponse(betterproto.Message):
    job_id: str = betterproto.string_field(1)
    is_running: bool = betterproto.bool_field(2)


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


@dataclass(eq=False, repr=False)
class IsJobAcquiringDataResponse(betterproto.Message):
    job_id: str = betterproto.string_field(1)
    acquiring_status: "IsJobAcquiringDataResponseAcquiringStatus" = (
        betterproto.enum_field(2)
    )


@dataclass(eq=False, repr=False)
class QmDataRequest(betterproto.Message):
    io_value_request: List["IoValueRequest"] = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class QmDataResponse(betterproto.Message):
    io_value_response: List[
        "QmDataResponseIoValueResponse"
    ] = betterproto.message_field(1)
    success: bool = betterproto.bool_field(2)
    errors: List["_general_messages__.ErrorMessage"] = betterproto.message_field(3)


@dataclass(eq=False, repr=False)
class QmDataResponseIoValueResponse(betterproto.Message):
    request: "IoValueRequest" = betterproto.message_field(1)
    values: "_compiler__.QuaValues" = betterproto.message_field(2)


@dataclass(eq=False, repr=False)
class IoValueRequest(betterproto.Message):
    pulser_number: int = betterproto.uint32_field(1)
    io_number: int = betterproto.uint32_field(2)
    job_id: str = betterproto.string_field(3, group="identifier_one_of")
    quantum_machine_id: str = betterproto.string_field(4, group="identifier_one_of")

    def __post_init__(self) -> None:
        super().__post_init__()
        if self.is_set("pulser_number"):
            warnings.warn(
                "IoValueRequest.pulser_number is deprecated", DeprecationWarning
            )


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

    def __post_init__(self) -> None:
        super().__post_init__()
        if self.is_set("pulsers_bitmap"):
            warnings.warn(
                "ResumeRequest.pulsers_bitmap is deprecated", DeprecationWarning
            )


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


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


@dataclass(eq=False, repr=False)
class PausedStatusResponse(betterproto.Message):
    pulsers_bitmap: int = betterproto.uint32_field(1)
    ok: bool = betterproto.bool_field(2)
    is_paused: bool = betterproto.bool_field(3)

    def __post_init__(self) -> None:
        super().__post_init__()
        if self.is_set("pulsers_bitmap"):
            warnings.warn(
                "PausedStatusResponse.pulsers_bitmap is deprecated", DeprecationWarning
            )


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


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


@dataclass(eq=False, repr=False)
class PullResultResponse(betterproto.Message):
    data: bytes = betterproto.bytes_field(1)
    offset: int = betterproto.uint32_field(2)
    bytes_left: int = betterproto.uint32_field(3)
    controller_name: str = betterproto.string_field(4)
    application_number: int = betterproto.uint32_field(5)
    implementation_name: str = betterproto.string_field(6)


@dataclass(eq=False, repr=False)
class HealthCheckResponse(betterproto.Message):
    message: List[str] = betterproto.string_field(1)
    ok: bool = betterproto.bool_field(2)
    error_messages: List[str] = betterproto.string_field(3)
    warning_messages: List[str] = betterproto.string_field(4)


@dataclass(eq=False, repr=False)
class ExecutionRequest(betterproto.Message):
    """Execution request"""

    high_level_program: "_qua__.QuaProgram" = betterproto.message_field(
        1, group="program_one_of"
    )
    low_level_program: bytes = betterproto.bytes_field(2, group="program_one_of")
    stream_duration_limit: int = betterproto.uint32_field(3)
    """
    Stream limitation, time in milliseconds and data in records (4ns worth of raw data
     or a single icp/seq record).
    """

    stream_data_limit: int = betterproto.uint32_field(4)
    force_execution: bool = betterproto.bool_field(5)
    """
    Force the execution. If another job is currently running, terminate it.
    """

    simulate: "ExecutionRequestSimulate" = betterproto.message_field(6)
    """The duration to simulate and provide results for"""

    dry_run: bool = betterproto.bool_field(7)
    quantum_machine_id: str = betterproto.string_field(8)
    """The id of the qm that will execute the program"""

    def __post_init__(self) -> None:
        super().__post_init__()
        if self.is_set("low_level_program"):
            warnings.warn(
                "ExecutionRequest.low_level_program is deprecated", DeprecationWarning
            )


@dataclass(eq=False, repr=False)
class ExecutionRequestSimulate(betterproto.Message):
    duration: int = betterproto.uint32_field(1)
    simulate_analog_outputs: bool = betterproto.bool_field(2)
    simulate_digital_outputs: bool = betterproto.bool_field(3)
    include_analog_samples: bool = betterproto.bool_field(4)
    include_digital_samples: bool = betterproto.bool_field(5)
    include_analog_waveforms: bool = betterproto.bool_field(6)
    include_digital_waveforms: bool = betterproto.bool_field(7)
    simulation_interface: "ExecutionRequestSimulateSimulationInterface" = (
        betterproto.message_field(8)
    )
    extra_processing_timeout_ms: int = betterproto.int32_field(9)

    def __post_init__(self) -> None:
        super().__post_init__()
        if self.is_set("simulate_analog_outputs"):
            warnings.warn(
                "ExecutionRequestSimulate.simulate_analog_outputs is deprecated",
                DeprecationWarning,
            )
        if self.is_set("simulate_digital_outputs"):
            warnings.warn(
                "ExecutionRequestSimulate.simulate_digital_outputs is deprecated",
                DeprecationWarning,
            )
        if self.is_set("include_analog_samples"):
            warnings.warn(
                "ExecutionRequestSimulate.include_analog_samples is deprecated",
                DeprecationWarning,
            )
        if self.is_set("include_digital_samples"):
            warnings.warn(
                "ExecutionRequestSimulate.include_digital_samples is deprecated",
                DeprecationWarning,
            )


@dataclass(eq=False, repr=False)
class ExecutionRequestSimulateSimulationInterface(betterproto.Message):
    none: "ExecutionRequestSimulateSimulationInterfaceNone" = betterproto.message_field(
        1, group="interface_oneof"
    )
    loopback: "ExecutionRequestSimulateSimulationInterfaceLoopback" = (
        betterproto.message_field(2, group="interface_oneof")
    )
    qsim: "ExecutionRequestSimulateSimulationInterfaceQSim" = betterproto.message_field(
        3, group="interface_oneof"
    )
    raw: "ExecutionRequestSimulateSimulationInterfaceRawInterface" = (
        betterproto.message_field(4, group="interface_oneof")
    )
    quantum_simulator: "ExecutionRequestSimulateSimulationInterfaceQuantumSimulatorInterface" = betterproto.message_field(
        5, group="interface_oneof"
    )


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


@dataclass(eq=False, repr=False)
class ExecutionRequestSimulateSimulationInterfaceLoopback(betterproto.Message):
    connections: List[
        "ExecutionRequestSimulateSimulationInterfaceLoopbackConnections"
    ] = betterproto.message_field(2)
    latency: int = betterproto.uint32_field(3)
    noise_power: float = betterproto.double_field(4)


@dataclass(eq=False, repr=False)
class ExecutionRequestSimulateSimulationInterfaceLoopbackConnections(
    betterproto.Message
):
    from_controller: str = betterproto.string_field(1)
    from_fem: int = betterproto.int32_field(5)
    from_port: int = betterproto.int32_field(2)
    to_controller: str = betterproto.string_field(3)
    to_fem: int = betterproto.int32_field(6)
    to_port: int = betterproto.int32_field(4)


@dataclass(eq=False, repr=False)
class ExecutionRequestSimulateSimulationInterfaceQSim(betterproto.Message):
    """TODO remove old quantum sim"""

    target: str = betterproto.string_field(1)
    job_id: str = betterproto.string_field(2)
    analog_out_connections: List[
        "ExecutionRequestSimulateSimulationInterfaceQSimConnections"
    ] = betterproto.message_field(3)
    digital_out_connections: List[
        "ExecutionRequestSimulateSimulationInterfaceQSimConnections"
    ] = betterproto.message_field(4)
    analog_in_connections: List[
        "ExecutionRequestSimulateSimulationInterfaceQSimConnections"
    ] = betterproto.message_field(5)


@dataclass(eq=False, repr=False)
class ExecutionRequestSimulateSimulationInterfaceQSimConnections(betterproto.Message):
    from_controller: str = betterproto.string_field(1)
    from_port: int = betterproto.int32_field(2)
    to_q_sim: str = betterproto.string_field(3)


@dataclass(eq=False, repr=False)
class ExecutionRequestSimulateSimulationInterfaceQuantumSimulatorInterface(
    betterproto.Message
):
    physical_config: bytes = betterproto.bytes_field(1)


@dataclass(eq=False, repr=False)
class ExecutionRequestSimulateSimulationInterfaceRawInterface(betterproto.Message):
    connections: List[
        "ExecutionRequestSimulateSimulationInterfaceRawInterfaceConnections"
    ] = betterproto.message_field(1)
    noise_power: float = betterproto.double_field(2)


@dataclass(eq=False, repr=False)
class ExecutionRequestSimulateSimulationInterfaceRawInterfaceConnections(
    betterproto.Message
):
    from_controller: str = betterproto.string_field(1)
    from_fem: int = betterproto.int32_field(4)
    from_port: int = betterproto.int32_field(2)
    to_samples: List[float] = betterproto.double_field(3)


@dataclass(eq=False, repr=False)
class ExecutionResponse(betterproto.Message):
    ok: bool = betterproto.bool_field(1)
    job_id: str = betterproto.string_field(2)
    messages: List["_compiler__.CompilerMessage"] = betterproto.message_field(3)
    metadata: str = betterproto.string_field(4)
    simulated: "SimulatedResponsePart" = betterproto.message_field(6)
    config: "_qua_config__.QuaConfig" = betterproto.message_field(7)
    """The config used for execution (only filled for high level execution)"""


@dataclass(eq=False, repr=False)
class SimulatedResponsePart(betterproto.Message):
    analog_outputs: "betterproto_lib_google_protobuf.Struct" = (
        betterproto.message_field(1)
    )
    digital_outputs: "betterproto_lib_google_protobuf.Struct" = (
        betterproto.message_field(2)
    )
    waveform_report: "betterproto_lib_google_protobuf.Struct" = (
        betterproto.message_field(4)
    )
    errors: List[str] = betterproto.string_field(3)

    def __post_init__(self) -> None:
        super().__post_init__()
        if self.is_set("analog_outputs"):
            warnings.warn(
                "SimulatedResponsePart.analog_outputs is deprecated", DeprecationWarning
            )
        if self.is_set("digital_outputs"):
            warnings.warn(
                "SimulatedResponsePart.digital_outputs is deprecated",
                DeprecationWarning,
            )


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


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


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


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


@dataclass(eq=False, repr=False)
class PeekRequest(betterproto.Message):
    address: int = betterproto.uint32_field(1)
    controller_id: str = betterproto.string_field(2)


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


@dataclass(eq=False, repr=False)
class PokeRequest(betterproto.Message):
    address: int = betterproto.uint32_field(1)
    value: int = betterproto.uint32_field(2)
    controller_id: str = betterproto.string_field(3)


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


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


@dataclass(eq=False, repr=False)
class GetSimulatedQuantumStateResponse(betterproto.Message):
    job_id: str = betterproto.string_field(1)
    ok: bool = betterproto.bool_field(2)
    state: "DensityMatrix" = betterproto.message_field(3)


@dataclass(eq=False, repr=False)
class DensityMatrix(betterproto.Message):
    time_stamp: int = betterproto.uint64_field(1)
    data: List["ComplexNumber"] = betterproto.message_field(2)


@dataclass(eq=False, repr=False)
class ComplexNumber(betterproto.Message):
    re: float = betterproto.double_field(1)
    im: float = betterproto.double_field(2)


@dataclass(eq=False, repr=False)
class PerformHalDebugCommandRequest(betterproto.Message):
    controller_name: str = betterproto.string_field(1)
    command: str = betterproto.string_field(2)


@dataclass(eq=False, repr=False)
class PerformHalDebugCommandResponse(betterproto.Message):
    success: bool = betterproto.bool_field(1)
    response: str = betterproto.string_field(2)


class FrontendStub(betterproto.ServiceStub):
    async def get_version(
        self,
        betterproto_lib_google_protobuf_empty: "betterproto_lib_google_protobuf.Empty",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "betterproto_lib_google_protobuf.StringValue":
        return await self._unary_unary(
            "/qm.grpc.frontend.Frontend/GetVersion",
            betterproto_lib_google_protobuf_empty,
            betterproto_lib_google_protobuf.StringValue,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def health_check(
        self,
        betterproto_lib_google_protobuf_empty: "betterproto_lib_google_protobuf.Empty",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "HealthCheckResponse":
        return await self._unary_unary(
            "/qm.grpc.frontend.Frontend/HealthCheck",
            betterproto_lib_google_protobuf_empty,
            HealthCheckResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def execute(
        self,
        execution_request: "ExecutionRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "ExecutionResponse":
        return await self._unary_unary(
            "/qm.grpc.frontend.Frontend/Execute",
            execution_request,
            ExecutionResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

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

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

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

    async def remove_pending_jobs(
        self,
        job_query_params: "JobQueryParams",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "RemovePendingJobsResponse":
        return await self._unary_unary(
            "/qm.grpc.frontend.Frontend/RemovePendingJobs",
            job_query_params,
            RemovePendingJobsResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_pending_jobs(
        self,
        job_query_params: "JobQueryParams",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetPendingJobsResponse":
        return await self._unary_unary(
            "/qm.grpc.frontend.Frontend/GetPendingJobs",
            job_query_params,
            GetPendingJobsResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_job_execution_status(
        self,
        get_job_execution_status_request: "GetJobExecutionStatusRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetJobExecutionStatusResponse":
        return await self._unary_unary(
            "/qm.grpc.frontend.Frontend/GetJobExecutionStatus",
            get_job_execution_status_request,
            GetJobExecutionStatusResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_job_status_updates(
        self,
        get_job_execution_status_request: "GetJobExecutionStatusRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> AsyncIterator[GetJobExecutionStatusResponse]:
        async for response in self._unary_stream(
            "/qm.grpc.frontend.Frontend/GetJobStatusUpdates",
            get_job_execution_status_request,
            GetJobExecutionStatusResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        ):
            yield response

    async def paused_status(
        self,
        paused_status_request: "PausedStatusRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PausedStatusResponse":
        return await self._unary_unary(
            "/qm.grpc.frontend.Frontend/PausedStatus",
            paused_status_request,
            PausedStatusResponse,
            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.frontend.Frontend/Resume",
            resume_request,
            ResumeResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def halt(
        self,
        halt_request: "HaltRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "HaltResponse":
        return await self._unary_unary(
            "/qm.grpc.frontend.Frontend/Halt",
            halt_request,
            HaltResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

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

    async def validate_config(
        self,
        qua_config_qua_config: "_qua_config__.QuaConfig",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "_compiler__.ValidationResponse":
        return await self._unary_unary(
            "/qm.grpc.frontend.Frontend/ValidateConfig",
            qua_config_qua_config,
            _compiler__.ValidationResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def init(
        self,
        betterproto_lib_google_protobuf_empty: "betterproto_lib_google_protobuf.Empty",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "betterproto_lib_google_protobuf.Empty":
        return await self._unary_unary(
            "/qm.grpc.frontend.Frontend/Init",
            betterproto_lib_google_protobuf_empty,
            betterproto_lib_google_protobuf.Empty,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def perform_qm_request(
        self,
        qm_api_high_qm_api_request: "_qm_api__.HighQmApiRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "_qm_api__.HighQmApiResponse":
        return await self._unary_unary(
            "/qm.grpc.frontend.Frontend/PerformQmRequest",
            qm_api_high_qm_api_request,
            _qm_api__.HighQmApiResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def request_data(
        self,
        qm_data_request: "QmDataRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "QmDataResponse":
        return await self._unary_unary(
            "/qm.grpc.frontend.Frontend/RequestData",
            qm_data_request,
            QmDataResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def pull_simulator_samples(
        self,
        results_analyser_pull_simulator_samples_request: "_results_analyser__.PullSimulatorSamplesRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> AsyncIterator[_results_analyser__.SimulatorSamplesResponse]:
        async for response in self._unary_stream(
            "/qm.grpc.frontend.Frontend/PullSimulatorSamples",
            results_analyser_pull_simulator_samples_request,
            _results_analyser__.SimulatorSamplesResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        ):
            yield response

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

    async def close_quantum_machine(
        self,
        qm_manager_close_quantum_machine_request: "_qm_manager__.CloseQuantumMachineRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "_qm_manager__.CloseQuantumMachineResponse":
        return await self._unary_unary(
            "/qm.grpc.frontend.Frontend/CloseQuantumMachine",
            qm_manager_close_quantum_machine_request,
            _qm_manager__.CloseQuantumMachineResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_quantum_machine(
        self,
        qm_manager_get_quantum_machine_request: "_qm_manager__.GetQuantumMachineRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "_qm_manager__.GetQuantumMachineResponse":
        return await self._unary_unary(
            "/qm.grpc.frontend.Frontend/GetQuantumMachine",
            qm_manager_get_quantum_machine_request,
            _qm_manager__.GetQuantumMachineResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_running_job(
        self,
        qm_manager_get_running_job_request: "_qm_manager__.GetRunningJobRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "_qm_manager__.GetRunningJobResponse":
        return await self._unary_unary(
            "/qm.grpc.frontend.Frontend/GetRunningJob",
            qm_manager_get_running_job_request,
            _qm_manager__.GetRunningJobResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def list_open_quantum_machines(
        self,
        betterproto_lib_google_protobuf_empty: "betterproto_lib_google_protobuf.Empty",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "_qm_manager__.ListOpenQuantumMachinesResponse":
        return await self._unary_unary(
            "/qm.grpc.frontend.Frontend/ListOpenQuantumMachines",
            betterproto_lib_google_protobuf_empty,
            _qm_manager__.ListOpenQuantumMachinesResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def close_all_quantum_machines(
        self,
        betterproto_lib_google_protobuf_empty: "betterproto_lib_google_protobuf.Empty",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "_qm_manager__.CloseAllQuantumMachinesResponse":
        return await self._unary_unary(
            "/qm.grpc.frontend.Frontend/CloseAllQuantumMachines",
            betterproto_lib_google_protobuf_empty,
            _qm_manager__.CloseAllQuantumMachinesResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_controllers(
        self,
        betterproto_lib_google_protobuf_empty: "betterproto_lib_google_protobuf.Empty",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "_qm_manager__.GetControllersResponse":
        return await self._unary_unary(
            "/qm.grpc.frontend.Frontend/GetControllers",
            betterproto_lib_google_protobuf_empty,
            _qm_manager__.GetControllersResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def is_job_running(
        self,
        is_job_running_request: "IsJobRunningRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "IsJobRunningResponse":
        return await self._unary_unary(
            "/qm.grpc.frontend.Frontend/IsJobRunning",
            is_job_running_request,
            IsJobRunningResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def is_job_acquiring_data(
        self,
        is_job_acquiring_data_request: "IsJobAcquiringDataRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "IsJobAcquiringDataResponse":
        return await self._unary_unary(
            "/qm.grpc.frontend.Frontend/IsJobAcquiringData",
            is_job_acquiring_data_request,
            IsJobAcquiringDataResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def simulate(
        self,
        simulation_request: "SimulationRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "SimulationResponse":
        return await self._unary_unary(
            "/qm.grpc.frontend.Frontend/Simulate",
            simulation_request,
            SimulationResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def clear_all_job_results(
        self,
        betterproto_lib_google_protobuf_empty: "betterproto_lib_google_protobuf.Empty",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "betterproto_lib_google_protobuf.Empty":
        return await self._unary_unary(
            "/qm.grpc.frontend.Frontend/ClearAllJobResults",
            betterproto_lib_google_protobuf_empty,
            betterproto_lib_google_protobuf.Empty,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def perform_hal_debug_command(
        self,
        perform_hal_debug_command_request: "PerformHalDebugCommandRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PerformHalDebugCommandResponse":
        return await self._unary_unary(
            "/qm.grpc.frontend.Frontend/PerformHalDebugCommand",
            perform_hal_debug_command_request,
            PerformHalDebugCommandResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_simulated_quantum_state(
        self,
        get_simulated_quantum_state_request: "GetSimulatedQuantumStateRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetSimulatedQuantumStateResponse":
        return await self._unary_unary(
            "/qm.grpc.frontend.Frontend/GetSimulatedQuantumState",
            get_simulated_quantum_state_request,
            GetSimulatedQuantumStateResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )


class FrontendBase(ServiceBase):
    async def get_version(
        self,
        betterproto_lib_google_protobuf_empty: "betterproto_lib_google_protobuf.Empty",
    ) -> "betterproto_lib_google_protobuf.StringValue":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def health_check(
        self,
        betterproto_lib_google_protobuf_empty: "betterproto_lib_google_protobuf.Empty",
    ) -> "HealthCheckResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def execute(
        self, execution_request: "ExecutionRequest"
    ) -> "ExecutionResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

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

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

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

    async def remove_pending_jobs(
        self, job_query_params: "JobQueryParams"
    ) -> "RemovePendingJobsResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_pending_jobs(
        self, job_query_params: "JobQueryParams"
    ) -> "GetPendingJobsResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_job_execution_status(
        self, get_job_execution_status_request: "GetJobExecutionStatusRequest"
    ) -> "GetJobExecutionStatusResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_job_status_updates(
        self, get_job_execution_status_request: "GetJobExecutionStatusRequest"
    ) -> AsyncIterator[GetJobExecutionStatusResponse]:
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
        yield GetJobExecutionStatusResponse()

    async def paused_status(
        self, paused_status_request: "PausedStatusRequest"
    ) -> "PausedStatusResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

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

    async def halt(self, halt_request: "HaltRequest") -> "HaltResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

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

    async def validate_config(
        self, qua_config_qua_config: "_qua_config__.QuaConfig"
    ) -> "_compiler__.ValidationResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def init(
        self,
        betterproto_lib_google_protobuf_empty: "betterproto_lib_google_protobuf.Empty",
    ) -> "betterproto_lib_google_protobuf.Empty":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def perform_qm_request(
        self, qm_api_high_qm_api_request: "_qm_api__.HighQmApiRequest"
    ) -> "_qm_api__.HighQmApiResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def request_data(self, qm_data_request: "QmDataRequest") -> "QmDataResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def pull_simulator_samples(
        self,
        results_analyser_pull_simulator_samples_request: "_results_analyser__.PullSimulatorSamplesRequest",
    ) -> AsyncIterator[_results_analyser__.SimulatorSamplesResponse]:
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
        yield _results_analyser__.SimulatorSamplesResponse()

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

    async def close_quantum_machine(
        self,
        qm_manager_close_quantum_machine_request: "_qm_manager__.CloseQuantumMachineRequest",
    ) -> "_qm_manager__.CloseQuantumMachineResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_quantum_machine(
        self,
        qm_manager_get_quantum_machine_request: "_qm_manager__.GetQuantumMachineRequest",
    ) -> "_qm_manager__.GetQuantumMachineResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_running_job(
        self, qm_manager_get_running_job_request: "_qm_manager__.GetRunningJobRequest"
    ) -> "_qm_manager__.GetRunningJobResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def list_open_quantum_machines(
        self,
        betterproto_lib_google_protobuf_empty: "betterproto_lib_google_protobuf.Empty",
    ) -> "_qm_manager__.ListOpenQuantumMachinesResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def close_all_quantum_machines(
        self,
        betterproto_lib_google_protobuf_empty: "betterproto_lib_google_protobuf.Empty",
    ) -> "_qm_manager__.CloseAllQuantumMachinesResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_controllers(
        self,
        betterproto_lib_google_protobuf_empty: "betterproto_lib_google_protobuf.Empty",
    ) -> "_qm_manager__.GetControllersResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def is_job_running(
        self, is_job_running_request: "IsJobRunningRequest"
    ) -> "IsJobRunningResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def is_job_acquiring_data(
        self, is_job_acquiring_data_request: "IsJobAcquiringDataRequest"
    ) -> "IsJobAcquiringDataResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def simulate(
        self, simulation_request: "SimulationRequest"
    ) -> "SimulationResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def clear_all_job_results(
        self,
        betterproto_lib_google_protobuf_empty: "betterproto_lib_google_protobuf.Empty",
    ) -> "betterproto_lib_google_protobuf.Empty":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def perform_hal_debug_command(
        self, perform_hal_debug_command_request: "PerformHalDebugCommandRequest"
    ) -> "PerformHalDebugCommandResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_simulated_quantum_state(
        self, get_simulated_quantum_state_request: "GetSimulatedQuantumStateRequest"
    ) -> "GetSimulatedQuantumStateResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def __rpc_get_version(
        self,
        stream: "grpclib.server.Stream[betterproto_lib_google_protobuf.Empty, betterproto_lib_google_protobuf.StringValue]",
    ) -> 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[betterproto_lib_google_protobuf.Empty, HealthCheckResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.health_check(request)
        await stream.send_message(response)

    async def __rpc_execute(
        self, stream: "grpclib.server.Stream[ExecutionRequest, ExecutionResponse]"
    ) -> 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[AddToQueueRequest, AddToQueueResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.add_to_queue(request)
        await stream.send_message(response)

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

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

    async def __rpc_remove_pending_jobs(
        self, stream: "grpclib.server.Stream[JobQueryParams, RemovePendingJobsResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.remove_pending_jobs(request)
        await stream.send_message(response)

    async def __rpc_get_pending_jobs(
        self, stream: "grpclib.server.Stream[JobQueryParams, GetPendingJobsResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_pending_jobs(request)
        await stream.send_message(response)

    async def __rpc_get_job_execution_status(
        self,
        stream: "grpclib.server.Stream[GetJobExecutionStatusRequest, GetJobExecutionStatusResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_job_execution_status(request)
        await stream.send_message(response)

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

    async def __rpc_paused_status(
        self, stream: "grpclib.server.Stream[PausedStatusRequest, PausedStatusResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.paused_status(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_halt(
        self, stream: "grpclib.server.Stream[HaltRequest, HaltResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.halt(request)
        await stream.send_message(response)

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

    async def __rpc_validate_config(
        self,
        stream: "grpclib.server.Stream[_qua_config__.QuaConfig, _compiler__.ValidationResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.validate_config(request)
        await stream.send_message(response)

    async def __rpc_init(
        self,
        stream: "grpclib.server.Stream[betterproto_lib_google_protobuf.Empty, betterproto_lib_google_protobuf.Empty]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.init(request)
        await stream.send_message(response)

    async def __rpc_perform_qm_request(
        self,
        stream: "grpclib.server.Stream[_qm_api__.HighQmApiRequest, _qm_api__.HighQmApiResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.perform_qm_request(request)
        await stream.send_message(response)

    async def __rpc_request_data(
        self, stream: "grpclib.server.Stream[QmDataRequest, QmDataResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.request_data(request)
        await stream.send_message(response)

    async def __rpc_pull_simulator_samples(
        self,
        stream: "grpclib.server.Stream[_results_analyser__.PullSimulatorSamplesRequest, _results_analyser__.SimulatorSamplesResponse]",
    ) -> None:
        request = await stream.recv_message()
        await self._call_rpc_handler_server_stream(
            self.pull_simulator_samples,
            stream,
            request,
        )

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

    async def __rpc_close_quantum_machine(
        self,
        stream: "grpclib.server.Stream[_qm_manager__.CloseQuantumMachineRequest, _qm_manager__.CloseQuantumMachineResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.close_quantum_machine(request)
        await stream.send_message(response)

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

    async def __rpc_get_running_job(
        self,
        stream: "grpclib.server.Stream[_qm_manager__.GetRunningJobRequest, _qm_manager__.GetRunningJobResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_running_job(request)
        await stream.send_message(response)

    async def __rpc_list_open_quantum_machines(
        self,
        stream: "grpclib.server.Stream[betterproto_lib_google_protobuf.Empty, _qm_manager__.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[betterproto_lib_google_protobuf.Empty, _qm_manager__.CloseAllQuantumMachinesResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.close_all_quantum_machines(request)
        await stream.send_message(response)

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

    async def __rpc_is_job_running(
        self, stream: "grpclib.server.Stream[IsJobRunningRequest, IsJobRunningResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.is_job_running(request)
        await stream.send_message(response)

    async def __rpc_is_job_acquiring_data(
        self,
        stream: "grpclib.server.Stream[IsJobAcquiringDataRequest, IsJobAcquiringDataResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.is_job_acquiring_data(request)
        await stream.send_message(response)

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

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

    async def __rpc_perform_hal_debug_command(
        self,
        stream: "grpclib.server.Stream[PerformHalDebugCommandRequest, PerformHalDebugCommandResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.perform_hal_debug_command(request)
        await stream.send_message(response)

    async def __rpc_get_simulated_quantum_state(
        self,
        stream: "grpclib.server.Stream[GetSimulatedQuantumStateRequest, GetSimulatedQuantumStateResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_simulated_quantum_state(request)
        await stream.send_message(response)

    def __mapping__(self) -> Dict[str, grpclib.const.Handler]:
        return {
            "/qm.grpc.frontend.Frontend/GetVersion": grpclib.const.Handler(
                self.__rpc_get_version,
                grpclib.const.Cardinality.UNARY_UNARY,
                betterproto_lib_google_protobuf.Empty,
                betterproto_lib_google_protobuf.StringValue,
            ),
            "/qm.grpc.frontend.Frontend/HealthCheck": grpclib.const.Handler(
                self.__rpc_health_check,
                grpclib.const.Cardinality.UNARY_UNARY,
                betterproto_lib_google_protobuf.Empty,
                HealthCheckResponse,
            ),
            "/qm.grpc.frontend.Frontend/Execute": grpclib.const.Handler(
                self.__rpc_execute,
                grpclib.const.Cardinality.UNARY_UNARY,
                ExecutionRequest,
                ExecutionResponse,
            ),
            "/qm.grpc.frontend.Frontend/AddToQueue": grpclib.const.Handler(
                self.__rpc_add_to_queue,
                grpclib.const.Cardinality.UNARY_UNARY,
                AddToQueueRequest,
                AddToQueueResponse,
            ),
            "/qm.grpc.frontend.Frontend/Compile": grpclib.const.Handler(
                self.__rpc_compile,
                grpclib.const.Cardinality.UNARY_UNARY,
                CompileRequest,
                CompileResponse,
            ),
            "/qm.grpc.frontend.Frontend/AddCompiledToQueue": grpclib.const.Handler(
                self.__rpc_add_compiled_to_queue,
                grpclib.const.Cardinality.UNARY_UNARY,
                AddCompiledToQueueRequest,
                AddCompiledToQueueResponse,
            ),
            "/qm.grpc.frontend.Frontend/RemovePendingJobs": grpclib.const.Handler(
                self.__rpc_remove_pending_jobs,
                grpclib.const.Cardinality.UNARY_UNARY,
                JobQueryParams,
                RemovePendingJobsResponse,
            ),
            "/qm.grpc.frontend.Frontend/GetPendingJobs": grpclib.const.Handler(
                self.__rpc_get_pending_jobs,
                grpclib.const.Cardinality.UNARY_UNARY,
                JobQueryParams,
                GetPendingJobsResponse,
            ),
            "/qm.grpc.frontend.Frontend/GetJobExecutionStatus": grpclib.const.Handler(
                self.__rpc_get_job_execution_status,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetJobExecutionStatusRequest,
                GetJobExecutionStatusResponse,
            ),
            "/qm.grpc.frontend.Frontend/GetJobStatusUpdates": grpclib.const.Handler(
                self.__rpc_get_job_status_updates,
                grpclib.const.Cardinality.UNARY_STREAM,
                GetJobExecutionStatusRequest,
                GetJobExecutionStatusResponse,
            ),
            "/qm.grpc.frontend.Frontend/PausedStatus": grpclib.const.Handler(
                self.__rpc_paused_status,
                grpclib.const.Cardinality.UNARY_UNARY,
                PausedStatusRequest,
                PausedStatusResponse,
            ),
            "/qm.grpc.frontend.Frontend/Resume": grpclib.const.Handler(
                self.__rpc_resume,
                grpclib.const.Cardinality.UNARY_UNARY,
                ResumeRequest,
                ResumeResponse,
            ),
            "/qm.grpc.frontend.Frontend/Halt": grpclib.const.Handler(
                self.__rpc_halt,
                grpclib.const.Cardinality.UNARY_UNARY,
                HaltRequest,
                HaltResponse,
            ),
            "/qm.grpc.frontend.Frontend/ResetDataProcessing": grpclib.const.Handler(
                self.__rpc_reset_data_processing,
                grpclib.const.Cardinality.UNARY_UNARY,
                ResetDataProcessingRequest,
                ResetDataProcessingResponse,
            ),
            "/qm.grpc.frontend.Frontend/ValidateConfig": grpclib.const.Handler(
                self.__rpc_validate_config,
                grpclib.const.Cardinality.UNARY_UNARY,
                _qua_config__.QuaConfig,
                _compiler__.ValidationResponse,
            ),
            "/qm.grpc.frontend.Frontend/Init": grpclib.const.Handler(
                self.__rpc_init,
                grpclib.const.Cardinality.UNARY_UNARY,
                betterproto_lib_google_protobuf.Empty,
                betterproto_lib_google_protobuf.Empty,
            ),
            "/qm.grpc.frontend.Frontend/PerformQmRequest": grpclib.const.Handler(
                self.__rpc_perform_qm_request,
                grpclib.const.Cardinality.UNARY_UNARY,
                _qm_api__.HighQmApiRequest,
                _qm_api__.HighQmApiResponse,
            ),
            "/qm.grpc.frontend.Frontend/RequestData": grpclib.const.Handler(
                self.__rpc_request_data,
                grpclib.const.Cardinality.UNARY_UNARY,
                QmDataRequest,
                QmDataResponse,
            ),
            "/qm.grpc.frontend.Frontend/PullSimulatorSamples": grpclib.const.Handler(
                self.__rpc_pull_simulator_samples,
                grpclib.const.Cardinality.UNARY_STREAM,
                _results_analyser__.PullSimulatorSamplesRequest,
                _results_analyser__.SimulatorSamplesResponse,
            ),
            "/qm.grpc.frontend.Frontend/OpenQuantumMachine": grpclib.const.Handler(
                self.__rpc_open_quantum_machine,
                grpclib.const.Cardinality.UNARY_UNARY,
                _qm_manager__.OpenQuantumMachineRequest,
                _qm_manager__.OpenQuantumMachineResponse,
            ),
            "/qm.grpc.frontend.Frontend/CloseQuantumMachine": grpclib.const.Handler(
                self.__rpc_close_quantum_machine,
                grpclib.const.Cardinality.UNARY_UNARY,
                _qm_manager__.CloseQuantumMachineRequest,
                _qm_manager__.CloseQuantumMachineResponse,
            ),
            "/qm.grpc.frontend.Frontend/GetQuantumMachine": grpclib.const.Handler(
                self.__rpc_get_quantum_machine,
                grpclib.const.Cardinality.UNARY_UNARY,
                _qm_manager__.GetQuantumMachineRequest,
                _qm_manager__.GetQuantumMachineResponse,
            ),
            "/qm.grpc.frontend.Frontend/GetRunningJob": grpclib.const.Handler(
                self.__rpc_get_running_job,
                grpclib.const.Cardinality.UNARY_UNARY,
                _qm_manager__.GetRunningJobRequest,
                _qm_manager__.GetRunningJobResponse,
            ),
            "/qm.grpc.frontend.Frontend/ListOpenQuantumMachines": grpclib.const.Handler(
                self.__rpc_list_open_quantum_machines,
                grpclib.const.Cardinality.UNARY_UNARY,
                betterproto_lib_google_protobuf.Empty,
                _qm_manager__.ListOpenQuantumMachinesResponse,
            ),
            "/qm.grpc.frontend.Frontend/CloseAllQuantumMachines": grpclib.const.Handler(
                self.__rpc_close_all_quantum_machines,
                grpclib.const.Cardinality.UNARY_UNARY,
                betterproto_lib_google_protobuf.Empty,
                _qm_manager__.CloseAllQuantumMachinesResponse,
            ),
            "/qm.grpc.frontend.Frontend/GetControllers": grpclib.const.Handler(
                self.__rpc_get_controllers,
                grpclib.const.Cardinality.UNARY_UNARY,
                betterproto_lib_google_protobuf.Empty,
                _qm_manager__.GetControllersResponse,
            ),
            "/qm.grpc.frontend.Frontend/IsJobRunning": grpclib.const.Handler(
                self.__rpc_is_job_running,
                grpclib.const.Cardinality.UNARY_UNARY,
                IsJobRunningRequest,
                IsJobRunningResponse,
            ),
            "/qm.grpc.frontend.Frontend/IsJobAcquiringData": grpclib.const.Handler(
                self.__rpc_is_job_acquiring_data,
                grpclib.const.Cardinality.UNARY_UNARY,
                IsJobAcquiringDataRequest,
                IsJobAcquiringDataResponse,
            ),
            "/qm.grpc.frontend.Frontend/Simulate": grpclib.const.Handler(
                self.__rpc_simulate,
                grpclib.const.Cardinality.UNARY_UNARY,
                SimulationRequest,
                SimulationResponse,
            ),
            "/qm.grpc.frontend.Frontend/ClearAllJobResults": grpclib.const.Handler(
                self.__rpc_clear_all_job_results,
                grpclib.const.Cardinality.UNARY_UNARY,
                betterproto_lib_google_protobuf.Empty,
                betterproto_lib_google_protobuf.Empty,
            ),
            "/qm.grpc.frontend.Frontend/PerformHalDebugCommand": grpclib.const.Handler(
                self.__rpc_perform_hal_debug_command,
                grpclib.const.Cardinality.UNARY_UNARY,
                PerformHalDebugCommandRequest,
                PerformHalDebugCommandResponse,
            ),
            "/qm.grpc.frontend.Frontend/GetSimulatedQuantumState": grpclib.const.Handler(
                self.__rpc_get_simulated_quantum_state,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetSimulatedQuantumStateRequest,
                GetSimulatedQuantumStateResponse,
            ),
        }
