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

import grpc

from temporalio.api.workflowservice.v1 import (
    request_response_pb2 as temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2,
)


class WorkflowServiceStub(object):
    """WorkflowService API defines how Temporal SDKs and other clients interact with the Temporal server
    to create and interact with workflows and activities.

    Users are expected to call `StartWorkflowExecution` to create a new workflow execution.

    To drive workflows, a worker using a Temporal SDK must exist which regularly polls for workflow
    and activity tasks from the service. For each workflow task, the sdk must process the
    (incremental or complete) event history and respond back with any newly generated commands.

    For each activity task, the worker is expected to execute the user's code which implements that
    activity, responding with completion or failure.
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.RegisterNamespace = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/RegisterNamespace",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RegisterNamespaceRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RegisterNamespaceResponse.FromString,
        )
        self.DescribeNamespace = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/DescribeNamespace",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeNamespaceRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeNamespaceResponse.FromString,
        )
        self.ListNamespaces = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/ListNamespaces",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListNamespacesRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListNamespacesResponse.FromString,
        )
        self.UpdateNamespace = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/UpdateNamespace",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateNamespaceRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateNamespaceResponse.FromString,
        )
        self.DeprecateNamespace = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/DeprecateNamespace",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeprecateNamespaceRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeprecateNamespaceResponse.FromString,
        )
        self.StartWorkflowExecution = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/StartWorkflowExecution",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.StartWorkflowExecutionRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.StartWorkflowExecutionResponse.FromString,
        )
        self.ExecuteMultiOperation = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/ExecuteMultiOperation",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ExecuteMultiOperationRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ExecuteMultiOperationResponse.FromString,
        )
        self.GetWorkflowExecutionHistory = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/GetWorkflowExecutionHistory",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetWorkflowExecutionHistoryRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetWorkflowExecutionHistoryResponse.FromString,
        )
        self.GetWorkflowExecutionHistoryReverse = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/GetWorkflowExecutionHistoryReverse",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetWorkflowExecutionHistoryReverseRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetWorkflowExecutionHistoryReverseResponse.FromString,
        )
        self.PollWorkflowTaskQueue = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/PollWorkflowTaskQueue",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PollWorkflowTaskQueueRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PollWorkflowTaskQueueResponse.FromString,
        )
        self.RespondWorkflowTaskCompleted = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/RespondWorkflowTaskCompleted",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondWorkflowTaskCompletedRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondWorkflowTaskCompletedResponse.FromString,
        )
        self.RespondWorkflowTaskFailed = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/RespondWorkflowTaskFailed",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondWorkflowTaskFailedRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondWorkflowTaskFailedResponse.FromString,
        )
        self.PollActivityTaskQueue = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/PollActivityTaskQueue",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PollActivityTaskQueueRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PollActivityTaskQueueResponse.FromString,
        )
        self.RecordActivityTaskHeartbeat = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/RecordActivityTaskHeartbeat",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RecordActivityTaskHeartbeatRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RecordActivityTaskHeartbeatResponse.FromString,
        )
        self.RecordActivityTaskHeartbeatById = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/RecordActivityTaskHeartbeatById",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RecordActivityTaskHeartbeatByIdRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RecordActivityTaskHeartbeatByIdResponse.FromString,
        )
        self.RespondActivityTaskCompleted = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/RespondActivityTaskCompleted",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskCompletedRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskCompletedResponse.FromString,
        )
        self.RespondActivityTaskCompletedById = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/RespondActivityTaskCompletedById",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskCompletedByIdRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskCompletedByIdResponse.FromString,
        )
        self.RespondActivityTaskFailed = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/RespondActivityTaskFailed",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskFailedRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskFailedResponse.FromString,
        )
        self.RespondActivityTaskFailedById = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/RespondActivityTaskFailedById",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskFailedByIdRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskFailedByIdResponse.FromString,
        )
        self.RespondActivityTaskCanceled = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/RespondActivityTaskCanceled",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskCanceledRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskCanceledResponse.FromString,
        )
        self.RespondActivityTaskCanceledById = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/RespondActivityTaskCanceledById",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskCanceledByIdRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskCanceledByIdResponse.FromString,
        )
        self.RequestCancelWorkflowExecution = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/RequestCancelWorkflowExecution",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RequestCancelWorkflowExecutionRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RequestCancelWorkflowExecutionResponse.FromString,
        )
        self.SignalWorkflowExecution = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/SignalWorkflowExecution",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.SignalWorkflowExecutionRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.SignalWorkflowExecutionResponse.FromString,
        )
        self.SignalWithStartWorkflowExecution = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/SignalWithStartWorkflowExecution",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.SignalWithStartWorkflowExecutionRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.SignalWithStartWorkflowExecutionResponse.FromString,
        )
        self.ResetWorkflowExecution = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/ResetWorkflowExecution",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ResetWorkflowExecutionRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ResetWorkflowExecutionResponse.FromString,
        )
        self.TerminateWorkflowExecution = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/TerminateWorkflowExecution",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.TerminateWorkflowExecutionRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.TerminateWorkflowExecutionResponse.FromString,
        )
        self.DeleteWorkflowExecution = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/DeleteWorkflowExecution",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteWorkflowExecutionRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteWorkflowExecutionResponse.FromString,
        )
        self.ListOpenWorkflowExecutions = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/ListOpenWorkflowExecutions",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListOpenWorkflowExecutionsRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListOpenWorkflowExecutionsResponse.FromString,
        )
        self.ListClosedWorkflowExecutions = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/ListClosedWorkflowExecutions",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListClosedWorkflowExecutionsRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListClosedWorkflowExecutionsResponse.FromString,
        )
        self.ListWorkflowExecutions = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/ListWorkflowExecutions",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListWorkflowExecutionsRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListWorkflowExecutionsResponse.FromString,
        )
        self.ListArchivedWorkflowExecutions = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/ListArchivedWorkflowExecutions",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListArchivedWorkflowExecutionsRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListArchivedWorkflowExecutionsResponse.FromString,
        )
        self.ScanWorkflowExecutions = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/ScanWorkflowExecutions",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ScanWorkflowExecutionsRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ScanWorkflowExecutionsResponse.FromString,
        )
        self.CountWorkflowExecutions = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/CountWorkflowExecutions",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.CountWorkflowExecutionsRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.CountWorkflowExecutionsResponse.FromString,
        )
        self.GetSearchAttributes = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/GetSearchAttributes",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetSearchAttributesRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetSearchAttributesResponse.FromString,
        )
        self.RespondQueryTaskCompleted = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/RespondQueryTaskCompleted",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondQueryTaskCompletedRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondQueryTaskCompletedResponse.FromString,
        )
        self.ResetStickyTaskQueue = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/ResetStickyTaskQueue",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ResetStickyTaskQueueRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ResetStickyTaskQueueResponse.FromString,
        )
        self.ShutdownWorker = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/ShutdownWorker",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ShutdownWorkerRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ShutdownWorkerResponse.FromString,
        )
        self.QueryWorkflow = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/QueryWorkflow",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.QueryWorkflowRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.QueryWorkflowResponse.FromString,
        )
        self.DescribeWorkflowExecution = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/DescribeWorkflowExecution",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeWorkflowExecutionRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeWorkflowExecutionResponse.FromString,
        )
        self.DescribeTaskQueue = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/DescribeTaskQueue",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeTaskQueueRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeTaskQueueResponse.FromString,
        )
        self.GetClusterInfo = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/GetClusterInfo",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetClusterInfoRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetClusterInfoResponse.FromString,
        )
        self.GetSystemInfo = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/GetSystemInfo",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetSystemInfoRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetSystemInfoResponse.FromString,
        )
        self.ListTaskQueuePartitions = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/ListTaskQueuePartitions",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListTaskQueuePartitionsRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListTaskQueuePartitionsResponse.FromString,
        )
        self.CreateSchedule = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/CreateSchedule",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.CreateScheduleRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.CreateScheduleResponse.FromString,
        )
        self.DescribeSchedule = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/DescribeSchedule",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeScheduleRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeScheduleResponse.FromString,
        )
        self.UpdateSchedule = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/UpdateSchedule",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateScheduleRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateScheduleResponse.FromString,
        )
        self.PatchSchedule = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/PatchSchedule",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PatchScheduleRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PatchScheduleResponse.FromString,
        )
        self.ListScheduleMatchingTimes = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/ListScheduleMatchingTimes",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListScheduleMatchingTimesRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListScheduleMatchingTimesResponse.FromString,
        )
        self.DeleteSchedule = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/DeleteSchedule",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteScheduleRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteScheduleResponse.FromString,
        )
        self.ListSchedules = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/ListSchedules",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListSchedulesRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListSchedulesResponse.FromString,
        )
        self.UpdateWorkerBuildIdCompatibility = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/UpdateWorkerBuildIdCompatibility",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkerBuildIdCompatibilityRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkerBuildIdCompatibilityResponse.FromString,
        )
        self.GetWorkerBuildIdCompatibility = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/GetWorkerBuildIdCompatibility",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetWorkerBuildIdCompatibilityRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetWorkerBuildIdCompatibilityResponse.FromString,
        )
        self.UpdateWorkerVersioningRules = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/UpdateWorkerVersioningRules",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkerVersioningRulesRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkerVersioningRulesResponse.FromString,
        )
        self.GetWorkerVersioningRules = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/GetWorkerVersioningRules",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetWorkerVersioningRulesRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetWorkerVersioningRulesResponse.FromString,
        )
        self.GetWorkerTaskReachability = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/GetWorkerTaskReachability",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetWorkerTaskReachabilityRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetWorkerTaskReachabilityResponse.FromString,
        )
        self.DescribeDeployment = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/DescribeDeployment",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeDeploymentRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeDeploymentResponse.FromString,
        )
        self.DescribeWorkerDeploymentVersion = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/DescribeWorkerDeploymentVersion",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeWorkerDeploymentVersionRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeWorkerDeploymentVersionResponse.FromString,
        )
        self.ListDeployments = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/ListDeployments",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListDeploymentsRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListDeploymentsResponse.FromString,
        )
        self.GetDeploymentReachability = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/GetDeploymentReachability",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetDeploymentReachabilityRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetDeploymentReachabilityResponse.FromString,
        )
        self.GetCurrentDeployment = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/GetCurrentDeployment",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetCurrentDeploymentRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetCurrentDeploymentResponse.FromString,
        )
        self.SetCurrentDeployment = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/SetCurrentDeployment",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.SetCurrentDeploymentRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.SetCurrentDeploymentResponse.FromString,
        )
        self.SetWorkerDeploymentCurrentVersion = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/SetWorkerDeploymentCurrentVersion",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.SetWorkerDeploymentCurrentVersionRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.SetWorkerDeploymentCurrentVersionResponse.FromString,
        )
        self.DescribeWorkerDeployment = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/DescribeWorkerDeployment",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeWorkerDeploymentRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeWorkerDeploymentResponse.FromString,
        )
        self.DeleteWorkerDeployment = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/DeleteWorkerDeployment",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteWorkerDeploymentRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteWorkerDeploymentResponse.FromString,
        )
        self.DeleteWorkerDeploymentVersion = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/DeleteWorkerDeploymentVersion",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteWorkerDeploymentVersionRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteWorkerDeploymentVersionResponse.FromString,
        )
        self.SetWorkerDeploymentRampingVersion = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/SetWorkerDeploymentRampingVersion",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.SetWorkerDeploymentRampingVersionRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.SetWorkerDeploymentRampingVersionResponse.FromString,
        )
        self.ListWorkerDeployments = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/ListWorkerDeployments",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListWorkerDeploymentsRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListWorkerDeploymentsResponse.FromString,
        )
        self.UpdateWorkerDeploymentVersionMetadata = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/UpdateWorkerDeploymentVersionMetadata",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkerDeploymentVersionMetadataRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkerDeploymentVersionMetadataResponse.FromString,
        )
        self.UpdateWorkflowExecution = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/UpdateWorkflowExecution",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkflowExecutionRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkflowExecutionResponse.FromString,
        )
        self.PollWorkflowExecutionUpdate = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/PollWorkflowExecutionUpdate",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PollWorkflowExecutionUpdateRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PollWorkflowExecutionUpdateResponse.FromString,
        )
        self.StartBatchOperation = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/StartBatchOperation",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.StartBatchOperationRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.StartBatchOperationResponse.FromString,
        )
        self.StopBatchOperation = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/StopBatchOperation",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.StopBatchOperationRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.StopBatchOperationResponse.FromString,
        )
        self.DescribeBatchOperation = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/DescribeBatchOperation",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeBatchOperationRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeBatchOperationResponse.FromString,
        )
        self.ListBatchOperations = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/ListBatchOperations",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListBatchOperationsRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListBatchOperationsResponse.FromString,
        )
        self.PollNexusTaskQueue = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/PollNexusTaskQueue",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PollNexusTaskQueueRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PollNexusTaskQueueResponse.FromString,
        )
        self.RespondNexusTaskCompleted = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/RespondNexusTaskCompleted",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondNexusTaskCompletedRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondNexusTaskCompletedResponse.FromString,
        )
        self.RespondNexusTaskFailed = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/RespondNexusTaskFailed",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondNexusTaskFailedRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondNexusTaskFailedResponse.FromString,
        )
        self.UpdateActivityOptions = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/UpdateActivityOptions",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateActivityOptionsRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateActivityOptionsResponse.FromString,
        )
        self.UpdateWorkflowExecutionOptions = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/UpdateWorkflowExecutionOptions",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkflowExecutionOptionsRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkflowExecutionOptionsResponse.FromString,
        )
        self.PauseActivity = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/PauseActivity",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PauseActivityRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PauseActivityResponse.FromString,
        )
        self.UnpauseActivity = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/UnpauseActivity",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UnpauseActivityRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UnpauseActivityResponse.FromString,
        )
        self.ResetActivity = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/ResetActivity",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ResetActivityRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ResetActivityResponse.FromString,
        )
        self.CreateWorkflowRule = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/CreateWorkflowRule",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.CreateWorkflowRuleRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.CreateWorkflowRuleResponse.FromString,
        )
        self.DescribeWorkflowRule = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/DescribeWorkflowRule",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeWorkflowRuleRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeWorkflowRuleResponse.FromString,
        )
        self.DeleteWorkflowRule = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/DeleteWorkflowRule",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteWorkflowRuleRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteWorkflowRuleResponse.FromString,
        )
        self.ListWorkflowRules = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/ListWorkflowRules",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListWorkflowRulesRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListWorkflowRulesResponse.FromString,
        )
        self.TriggerWorkflowRule = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/TriggerWorkflowRule",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.TriggerWorkflowRuleRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.TriggerWorkflowRuleResponse.FromString,
        )
        self.RecordWorkerHeartbeat = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/RecordWorkerHeartbeat",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RecordWorkerHeartbeatRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RecordWorkerHeartbeatResponse.FromString,
        )
        self.ListWorkers = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/ListWorkers",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListWorkersRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListWorkersResponse.FromString,
        )
        self.UpdateTaskQueueConfig = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/UpdateTaskQueueConfig",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateTaskQueueConfigRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateTaskQueueConfigResponse.FromString,
        )
        self.FetchWorkerConfig = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/FetchWorkerConfig",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.FetchWorkerConfigRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.FetchWorkerConfigResponse.FromString,
        )
        self.UpdateWorkerConfig = channel.unary_unary(
            "/temporal.api.workflowservice.v1.WorkflowService/UpdateWorkerConfig",
            request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkerConfigRequest.SerializeToString,
            response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkerConfigResponse.FromString,
        )


class WorkflowServiceServicer(object):
    """WorkflowService API defines how Temporal SDKs and other clients interact with the Temporal server
    to create and interact with workflows and activities.

    Users are expected to call `StartWorkflowExecution` to create a new workflow execution.

    To drive workflows, a worker using a Temporal SDK must exist which regularly polls for workflow
    and activity tasks from the service. For each workflow task, the sdk must process the
    (incremental or complete) event history and respond back with any newly generated commands.

    For each activity task, the worker is expected to execute the user's code which implements that
    activity, responding with completion or failure.
    """

    def RegisterNamespace(self, request, context):
        """RegisterNamespace creates a new namespace which can be used as a container for all resources.

        A Namespace is a top level entity within Temporal, and is used as a container for resources
        like workflow executions, task queues, etc. A Namespace acts as a sandbox and provides
        isolation for all resources within the namespace. All resources belongs to exactly one
        namespace.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def DescribeNamespace(self, request, context):
        """DescribeNamespace returns the information and configuration for a registered namespace."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListNamespaces(self, request, context):
        """ListNamespaces returns the information and configuration for all namespaces."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def UpdateNamespace(self, request, context):
        """UpdateNamespace is used to update the information and configuration of a registered
        namespace.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def DeprecateNamespace(self, request, context):
        """DeprecateNamespace is used to update the state of a registered namespace to DEPRECATED.

        Once the namespace is deprecated it cannot be used to start new workflow executions. Existing
        workflow executions will continue to run on deprecated namespaces.
        Deprecated.

        (-- api-linter: core::0127::http-annotation=disabled
        aip.dev/not-precedent: Deprecated --)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def StartWorkflowExecution(self, request, context):
        """StartWorkflowExecution starts a new workflow execution.

        It will create the execution with a `WORKFLOW_EXECUTION_STARTED` event in its history and
        also schedule the first workflow task. Returns `WorkflowExecutionAlreadyStarted`, if an
        instance already exists with same workflow id.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ExecuteMultiOperation(self, request, context):
        """ExecuteMultiOperation executes multiple operations within a single workflow.

        Operations are started atomically, meaning if *any* operation fails to be started, none are,
        and the request fails. Upon start, the API returns only when *all* operations have a response.

        Upon failure, it returns `MultiOperationExecutionFailure` where the status code
        equals the status code of the *first* operation that failed to be started.

        NOTE: Experimental API.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetWorkflowExecutionHistory(self, request, context):
        """GetWorkflowExecutionHistory returns the history of specified workflow execution. Fails with
        `NotFound` if the specified workflow execution is unknown to the service.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetWorkflowExecutionHistoryReverse(self, request, context):
        """GetWorkflowExecutionHistoryReverse returns the history of specified workflow execution in reverse
        order (starting from last event). Fails with`NotFound` if the specified workflow execution is
        unknown to the service.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def PollWorkflowTaskQueue(self, request, context):
        """PollWorkflowTaskQueue is called by workers to make progress on workflows.

        A WorkflowTask is dispatched to callers for active workflow executions with pending workflow
        tasks. The worker is expected to call `RespondWorkflowTaskCompleted` when it is done
        processing the task. The service will create a `WorkflowTaskStarted` event in the history for
        this task before handing it to the worker.

        (-- api-linter: core::0127::http-annotation=disabled
        aip.dev/not-precedent: We do not expose worker API to HTTP. --)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def RespondWorkflowTaskCompleted(self, request, context):
        """RespondWorkflowTaskCompleted is called by workers to successfully complete workflow tasks
        they received from `PollWorkflowTaskQueue`.

        Completing a WorkflowTask will write a `WORKFLOW_TASK_COMPLETED` event to the workflow's
        history, along with events corresponding to whatever commands the SDK generated while
        executing the task (ex timer started, activity task scheduled, etc).

        (-- api-linter: core::0127::http-annotation=disabled
        aip.dev/not-precedent: We do not expose worker API to HTTP. --)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def RespondWorkflowTaskFailed(self, request, context):
        """RespondWorkflowTaskFailed is called by workers to indicate the processing of a workflow task
        failed.

        This results in a `WORKFLOW_TASK_FAILED` event written to the history, and a new workflow
        task will be scheduled. This API can be used to report unhandled failures resulting from
        applying the workflow task.

        Temporal will only append first WorkflowTaskFailed event to the history of workflow execution
        for consecutive failures.

        (-- api-linter: core::0127::http-annotation=disabled
        aip.dev/not-precedent: We do not expose worker API to HTTP. --)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def PollActivityTaskQueue(self, request, context):
        """PollActivityTaskQueue is called by workers to process activity tasks from a specific task
        queue.

        The worker is expected to call one of the `RespondActivityTaskXXX` methods when it is done
        processing the task.

        An activity task is dispatched whenever a `SCHEDULE_ACTIVITY_TASK` command is produced during
        workflow execution. An in memory `ACTIVITY_TASK_STARTED` event is written to mutable state
        before the task is dispatched to the worker. The started event, and the final event
        (`ACTIVITY_TASK_COMPLETED` / `ACTIVITY_TASK_FAILED` / `ACTIVITY_TASK_TIMED_OUT`) will both be
        written permanently to Workflow execution history when Activity is finished. This is done to
        avoid writing many events in the case of a failure/retry loop.

        (-- api-linter: core::0127::http-annotation=disabled
        aip.dev/not-precedent: We do not expose worker API to HTTP. --)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def RecordActivityTaskHeartbeat(self, request, context):
        """RecordActivityTaskHeartbeat is optionally called by workers while they execute activities.

        If worker fails to heartbeat within the `heartbeat_timeout` interval for the activity task,
        then it will be marked as timed out and an `ACTIVITY_TASK_TIMED_OUT` event will be written to
        the workflow history. Calling `RecordActivityTaskHeartbeat` will fail with `NotFound` in
        such situations, in that event, the SDK should request cancellation of the activity.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def RecordActivityTaskHeartbeatById(self, request, context):
        """See `RecordActivityTaskHeartbeat`. This version allows clients to record heartbeats by
        namespace/workflow id/activity id instead of task token.

        (-- api-linter: core::0136::prepositions=disabled
        aip.dev/not-precedent: "By" is used to indicate request type. --)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def RespondActivityTaskCompleted(self, request, context):
        """RespondActivityTaskCompleted is called by workers when they successfully complete an activity
        task.

        This results in a new `ACTIVITY_TASK_COMPLETED` event being written to the workflow history
        and a new workflow task created for the workflow. Fails with `NotFound` if the task token is
        no longer valid due to activity timeout, already being completed, or never having existed.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def RespondActivityTaskCompletedById(self, request, context):
        """See `RecordActivityTaskCompleted`. This version allows clients to record completions by
        namespace/workflow id/activity id instead of task token.

        (-- api-linter: core::0136::prepositions=disabled
        aip.dev/not-precedent: "By" is used to indicate request type. --)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def RespondActivityTaskFailed(self, request, context):
        """RespondActivityTaskFailed is called by workers when processing an activity task fails.

        This results in a new `ACTIVITY_TASK_FAILED` event being written to the workflow history and
        a new workflow task created for the workflow. Fails with `NotFound` if the task token is no
        longer valid due to activity timeout, already being completed, or never having existed.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def RespondActivityTaskFailedById(self, request, context):
        """See `RecordActivityTaskFailed`. This version allows clients to record failures by
        namespace/workflow id/activity id instead of task token.

        (-- api-linter: core::0136::prepositions=disabled
        aip.dev/not-precedent: "By" is used to indicate request type. --)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def RespondActivityTaskCanceled(self, request, context):
        """RespondActivityTaskFailed is called by workers when processing an activity task fails.

        This results in a new `ACTIVITY_TASK_CANCELED` event being written to the workflow history
        and a new workflow task created for the workflow. Fails with `NotFound` if the task token is
        no longer valid due to activity timeout, already being completed, or never having existed.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def RespondActivityTaskCanceledById(self, request, context):
        """See `RecordActivityTaskCanceled`. This version allows clients to record failures by
        namespace/workflow id/activity id instead of task token.

        (-- api-linter: core::0136::prepositions=disabled
        aip.dev/not-precedent: "By" is used to indicate request type. --)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def RequestCancelWorkflowExecution(self, request, context):
        """RequestCancelWorkflowExecution is called by workers when they want to request cancellation of
        a workflow execution.

        This results in a new `WORKFLOW_EXECUTION_CANCEL_REQUESTED` event being written to the
        workflow history and a new workflow task created for the workflow. It returns success if the requested
        workflow is already closed. It fails with 'NotFound' if the requested workflow doesn't exist.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def SignalWorkflowExecution(self, request, context):
        """SignalWorkflowExecution is used to send a signal to a running workflow execution.

        This results in a `WORKFLOW_EXECUTION_SIGNALED` event recorded in the history and a workflow
        task being created for the execution.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def SignalWithStartWorkflowExecution(self, request, context):
        """SignalWithStartWorkflowExecution is used to ensure a signal is sent to a workflow, even if
        it isn't yet started.

        If the workflow is running, a `WORKFLOW_EXECUTION_SIGNALED` event is recorded in the history
        and a workflow task is generated.

        If the workflow is not running or not found, then the workflow is created with
        `WORKFLOW_EXECUTION_STARTED` and `WORKFLOW_EXECUTION_SIGNALED` events in its history, and a
        workflow task is generated.

        (-- api-linter: core::0136::prepositions=disabled
        aip.dev/not-precedent: "With" is used to indicate combined operation. --)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ResetWorkflowExecution(self, request, context):
        """ResetWorkflowExecution will reset an existing workflow execution to a specified
        `WORKFLOW_TASK_COMPLETED` event (exclusive). It will immediately terminate the current
        execution instance.
        TODO: Does exclusive here mean *just* the completed event, or also WFT started? Otherwise the task is doomed to time out?
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def TerminateWorkflowExecution(self, request, context):
        """TerminateWorkflowExecution terminates an existing workflow execution by recording a
        `WORKFLOW_EXECUTION_TERMINATED` event in the history and immediately terminating the
        execution instance.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def DeleteWorkflowExecution(self, request, context):
        """DeleteWorkflowExecution asynchronously deletes a specific Workflow Execution (when
        WorkflowExecution.run_id is provided) or the latest Workflow Execution (when
        WorkflowExecution.run_id is not provided). If the Workflow Execution is Running, it will be
        terminated before deletion.

        (-- api-linter: core::0127::http-annotation=disabled
        aip.dev/not-precedent: Workflow deletion not exposed to HTTP, users should use cancel or terminate. --)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListOpenWorkflowExecutions(self, request, context):
        """ListOpenWorkflowExecutions is a visibility API to list the open executions in a specific namespace.

        (-- api-linter: core::0127::http-annotation=disabled
        aip.dev/not-precedent: HTTP users should use ListWorkflowExecutions instead. --)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListClosedWorkflowExecutions(self, request, context):
        """ListClosedWorkflowExecutions is a visibility API to list the closed executions in a specific namespace.

        (-- api-linter: core::0127::http-annotation=disabled
        aip.dev/not-precedent: HTTP users should use ListWorkflowExecutions instead. --)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListWorkflowExecutions(self, request, context):
        """ListWorkflowExecutions is a visibility API to list workflow executions in a specific namespace."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListArchivedWorkflowExecutions(self, request, context):
        """ListArchivedWorkflowExecutions is a visibility API to list archived workflow executions in a specific namespace."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ScanWorkflowExecutions(self, request, context):
        """ScanWorkflowExecutions is a visibility API to list large amount of workflow executions in a specific namespace without order.

        Deprecated: Replaced with `ListWorkflowExecutions`.
        (-- api-linter: core::0127::http-annotation=disabled
        aip.dev/not-precedent: HTTP users should use ListWorkflowExecutions instead. --)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def CountWorkflowExecutions(self, request, context):
        """CountWorkflowExecutions is a visibility API to count of workflow executions in a specific namespace."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetSearchAttributes(self, request, context):
        """GetSearchAttributes is a visibility API to get all legal keys that could be used in list APIs

        (-- api-linter: core::0127::http-annotation=disabled
        aip.dev/not-precedent: We do not expose this search attribute API to HTTP (but may expose on OperatorService). --)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def RespondQueryTaskCompleted(self, request, context):
        """RespondQueryTaskCompleted is called by workers to complete queries which were delivered on
        the `query` (not `queries`) field of a `PollWorkflowTaskQueueResponse`.

        Completing the query will unblock the corresponding client call to `QueryWorkflow` and return
        the query result a response.

        (-- api-linter: core::0127::http-annotation=disabled
        aip.dev/not-precedent: We do not expose worker API to HTTP. --)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ResetStickyTaskQueue(self, request, context):
        """ResetStickyTaskQueue resets the sticky task queue related information in the mutable state of
        a given workflow. This is prudent for workers to perform if a workflow has been paged out of
        their cache.

        Things cleared are:
        1. StickyTaskQueue
        2. StickyScheduleToStartTimeout

        When possible, ShutdownWorker should be preferred over
        ResetStickyTaskQueue (particularly when a worker is shutting down or
        cycling).

        (-- api-linter: core::0127::http-annotation=disabled
        aip.dev/not-precedent: We do not expose worker API to HTTP. --)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ShutdownWorker(self, request, context):
        """ShutdownWorker is used to indicate that the given sticky task
        queue is no longer being polled by its worker. Following the completion of
        ShutdownWorker, newly-added workflow tasks will instead be placed
        in the normal task queue, eligible for any worker to pick up.

        ShutdownWorker should be called by workers while shutting down,
        after they've shut down their pollers. If another sticky poll
        request is issued, the sticky task queue will be revived.

        As of Temporal Server v1.25.0, ShutdownWorker hasn't yet been implemented.

        (-- api-linter: core::0127::http-annotation=disabled
        aip.dev/not-precedent: We do not expose worker API to HTTP. --)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def QueryWorkflow(self, request, context):
        """QueryWorkflow requests a query be executed for a specified workflow execution."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def DescribeWorkflowExecution(self, request, context):
        """DescribeWorkflowExecution returns information about the specified workflow execution."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def DescribeTaskQueue(self, request, context):
        """DescribeTaskQueue returns the following information about the target task queue, broken down by Build ID:
        - List of pollers
        - Workflow Reachability status
        - Backlog info for Workflow and/or Activity tasks
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetClusterInfo(self, request, context):
        """GetClusterInfo returns information about temporal cluster"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetSystemInfo(self, request, context):
        """GetSystemInfo returns information about the system."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListTaskQueuePartitions(self, request, context):
        """(-- api-linter: core::0127::http-annotation=disabled
        aip.dev/not-precedent: We do not expose this low-level API to HTTP. --)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def CreateSchedule(self, request, context):
        """Creates a new schedule."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def DescribeSchedule(self, request, context):
        """Returns the schedule description and current state of an existing schedule."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def UpdateSchedule(self, request, context):
        """Changes the configuration or state of an existing schedule."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def PatchSchedule(self, request, context):
        """Makes a specific change to a schedule or triggers an immediate action."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListScheduleMatchingTimes(self, request, context):
        """Lists matching times within a range."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def DeleteSchedule(self, request, context):
        """Deletes a schedule, removing it from the system."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListSchedules(self, request, context):
        """List all schedules in a namespace."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def UpdateWorkerBuildIdCompatibility(self, request, context):
        """Deprecated. Use `UpdateWorkerVersioningRules`.

        Allows users to specify sets of worker build id versions on a per task queue basis. Versions
        are ordered, and may be either compatible with some extant version, or a new incompatible
        version, forming sets of ids which are incompatible with each other, but whose contained
        members are compatible with one another.

        A single build id may be mapped to multiple task queues using this API for cases where a single process hosts
        multiple workers.

        To query which workers can be retired, use the `GetWorkerTaskReachability` API.

        NOTE: The number of task queues mapped to a single build id is limited by the `limit.taskQueuesPerBuildId`
        (default is 20), if this limit is exceeded this API will error with a FailedPrecondition.

        (-- api-linter: core::0127::http-annotation=disabled
        aip.dev/not-precedent: We do yet expose versioning API to HTTP. --)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetWorkerBuildIdCompatibility(self, request, context):
        """Deprecated. Use `GetWorkerVersioningRules`.
        Fetches the worker build id versioning sets for a task queue.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def UpdateWorkerVersioningRules(self, request, context):
        """Use this API to manage Worker Versioning Rules for a given Task Queue. There are two types of
        rules: Build ID Assignment rules and Compatible Build ID Redirect rules.

        Assignment rules determine how to assign new executions to a Build IDs. Their primary
        use case is to specify the latest Build ID but they have powerful features for gradual rollout
        of a new Build ID.

        Once a workflow execution is assigned to a Build ID and it completes its first Workflow Task,
        the workflow stays on the assigned Build ID regardless of changes in assignment rules. This
        eliminates the need for compatibility between versions when you only care about using the new
        version for new workflows and let existing workflows finish in their own version.

        Activities, Child Workflows and Continue-as-New executions have the option to inherit the
        Build ID of their parent/previous workflow or use the latest assignment rules to independently
        select a Build ID.

        Redirect rules should only be used when you want to move workflows and activities assigned to
        one Build ID (source) to another compatible Build ID (target). You are responsible to make sure
        the target Build ID of a redirect rule is able to process event histories made by the source
        Build ID by using [Patching](https://docs.temporal.io/workflows#patching) or other means.

        WARNING: Worker Versioning is not yet stable and the API and behavior may change incompatibly.
        (-- api-linter: core::0127::http-annotation=disabled
        aip.dev/not-precedent: We do yet expose versioning API to HTTP. --)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetWorkerVersioningRules(self, request, context):
        """Fetches the Build ID assignment and redirect rules for a Task Queue.
        WARNING: Worker Versioning is not yet stable and the API and behavior may change incompatibly.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetWorkerTaskReachability(self, request, context):
        """Deprecated. Use `DescribeTaskQueue`.

        Fetches task reachability to determine whether a worker may be retired.
        The request may specify task queues to query for or let the server fetch all task queues mapped to the given
        build IDs.

        When requesting a large number of task queues or all task queues associated with the given build ids in a
        namespace, all task queues will be listed in the response but some of them may not contain reachability
        information due to a server enforced limit. When reaching the limit, task queues that reachability information
        could not be retrieved for will be marked with a single TASK_REACHABILITY_UNSPECIFIED entry. The caller may issue
        another call to get the reachability for those task queues.

        Open source users can adjust this limit by setting the server's dynamic config value for
        `limit.reachabilityTaskQueueScan` with the caveat that this call can strain the visibility store.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def DescribeDeployment(self, request, context):
        """Describes a worker deployment.
        Experimental. This API might significantly change or be removed in a future release.
        Deprecated. Replaced with `DescribeWorkerDeploymentVersion`.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def DescribeWorkerDeploymentVersion(self, request, context):
        """Describes a worker deployment version.
        Experimental. This API might significantly change or be removed in a future release.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListDeployments(self, request, context):
        """Lists worker deployments in the namespace. Optionally can filter based on deployment series
        name.
        Experimental. This API might significantly change or be removed in a future release.
        Deprecated. Replaced with `ListWorkerDeployments`.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetDeploymentReachability(self, request, context):
        """Returns the reachability level of a worker deployment to help users decide when it is time
        to decommission a deployment. Reachability level is calculated based on the deployment's
        `status` and existing workflows that depend on the given deployment for their execution.
        Calculating reachability is relatively expensive. Therefore, server might return a recently
        cached value. In such a case, the `last_update_time` will inform you about the actual
        reachability calculation time.
        Experimental. This API might significantly change or be removed in a future release.
        Deprecated. Replaced with `DrainageInfo` returned by `DescribeWorkerDeploymentVersion`.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def GetCurrentDeployment(self, request, context):
        """Returns the current deployment (and its info) for a given deployment series.
        Experimental. This API might significantly change or be removed in a future release.
        Deprecated. Replaced by `current_version` returned by `DescribeWorkerDeployment`.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def SetCurrentDeployment(self, request, context):
        """Sets a deployment as the current deployment for its deployment series. Can optionally update
        the metadata of the deployment as well.
        Experimental. This API might significantly change or be removed in a future release.
        Deprecated. Replaced by `SetWorkerDeploymentCurrentVersion`.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def SetWorkerDeploymentCurrentVersion(self, request, context):
        """Set/unset the Current Version of a Worker Deployment. Automatically unsets the Ramping
        Version if it is the Version being set as Current.
        Experimental. This API might significantly change or be removed in a future release.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def DescribeWorkerDeployment(self, request, context):
        """Describes a Worker Deployment.
        Experimental. This API might significantly change or be removed in a future release.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def DeleteWorkerDeployment(self, request, context):
        """Deletes records of (an old) Deployment. A deployment can only be deleted if
        it has no Version in it.
        Experimental. This API might significantly change or be removed in a future release.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def DeleteWorkerDeploymentVersion(self, request, context):
        """Used for manual deletion of Versions. User can delete a Version only when all the
        following conditions are met:
        - It is not the Current or Ramping Version of its Deployment.
        - It has no active pollers (none of the task queues in the Version have pollers)
        - It is not draining (see WorkerDeploymentVersionInfo.drainage_info). This condition
        can be skipped by passing `skip-drainage=true`.
        Experimental. This API might significantly change or be removed in a future release.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def SetWorkerDeploymentRampingVersion(self, request, context):
        """Set/unset the Ramping Version of a Worker Deployment and its ramp percentage. Can be used for
        gradual ramp to unversioned workers too.
        Experimental. This API might significantly change or be removed in a future release.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListWorkerDeployments(self, request, context):
        """Lists all Worker Deployments that are tracked in the Namespace.
        Experimental. This API might significantly change or be removed in a future release.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def UpdateWorkerDeploymentVersionMetadata(self, request, context):
        """Updates the user-given metadata attached to a Worker Deployment Version.
        Experimental. This API might significantly change or be removed in a future release.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def UpdateWorkflowExecution(self, request, context):
        """Invokes the specified Update function on user Workflow code."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def PollWorkflowExecutionUpdate(self, request, context):
        """Polls a Workflow Execution for the outcome of a Workflow Update
        previously issued through the UpdateWorkflowExecution RPC. The effective
        timeout on this call will be shorter of the the caller-supplied gRPC
        timeout and the server's configured long-poll timeout.

        (-- api-linter: core::0127::http-annotation=disabled
        aip.dev/not-precedent: We don't expose update polling API to HTTP in favor of a potential future non-blocking form. --)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def StartBatchOperation(self, request, context):
        """StartBatchOperation starts a new batch operation"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def StopBatchOperation(self, request, context):
        """StopBatchOperation stops a batch operation"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def DescribeBatchOperation(self, request, context):
        """DescribeBatchOperation returns the information about a batch operation"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListBatchOperations(self, request, context):
        """ListBatchOperations returns a list of batch operations"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def PollNexusTaskQueue(self, request, context):
        """PollNexusTaskQueue is a long poll call used by workers to receive Nexus tasks.
        (-- api-linter: core::0127::http-annotation=disabled
        aip.dev/not-precedent: We do not expose worker API to HTTP. --)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def RespondNexusTaskCompleted(self, request, context):
        """RespondNexusTaskCompleted is called by workers to respond to Nexus tasks received via PollNexusTaskQueue.
        (-- api-linter: core::0127::http-annotation=disabled
        aip.dev/not-precedent: We do not expose worker API to HTTP. --)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def RespondNexusTaskFailed(self, request, context):
        """RespondNexusTaskFailed is called by workers to fail Nexus tasks received via PollNexusTaskQueue.
        (-- api-linter: core::0127::http-annotation=disabled
        aip.dev/not-precedent: We do not expose worker API to HTTP. --)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def UpdateActivityOptions(self, request, context):
        """UpdateActivityOptions is called by the client to update the options of an activity by its ID or type.
        If there are multiple pending activities of the provided type - all of them will be updated.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def UpdateWorkflowExecutionOptions(self, request, context):
        """UpdateWorkflowExecutionOptions partially updates the WorkflowExecutionOptions of an existing workflow execution."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def PauseActivity(self, request, context):
        """PauseActivity pauses the execution of an activity specified by its ID or type.
        If there are multiple pending activities of the provided type - all of them will be paused

        Pausing an activity means:
        - If the activity is currently waiting for a retry or is running and subsequently fails,
        it will not be rescheduled until it is unpaused.
        - If the activity is already paused, calling this method will have no effect.
        - If the activity is running and finishes successfully, the activity will be completed.
        - If the activity is running and finishes with failure:
        * if there is no retry left - the activity will be completed.
        * if there are more retries left - the activity will be paused.
        For long-running activities:
        - activities in paused state will send a cancellation with "activity_paused" set to 'true' in response to 'RecordActivityTaskHeartbeat'.
        - The activity should respond to the cancellation accordingly.

        Returns a `NotFound` error if there is no pending activity with the provided ID or type
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def UnpauseActivity(self, request, context):
        """UnpauseActivity unpauses the execution of an activity specified by its ID or type.
        If there are multiple pending activities of the provided type - all of them will be unpaused.

        If activity is not paused, this call will have no effect.
        If the activity was paused while waiting for retry, it will be scheduled immediately (* see 'jitter' flag).
        Once the activity is unpaused, all timeout timers will be regenerated.

        Flags:
        'jitter': the activity will be scheduled at a random time within the jitter duration.
        'reset_attempts': the number of attempts will be reset.
        'reset_heartbeat': the activity heartbeat timer and heartbeats will be reset.

        Returns a `NotFound` error if there is no pending activity with the provided ID or type
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ResetActivity(self, request, context):
        """ResetActivity resets the execution of an activity specified by its ID or type.
        If there are multiple pending activities of the provided type - all of them will be reset.

        Resetting an activity means:
        * number of attempts will be reset to 0.
        * activity timeouts will be reset.
        * if the activity is waiting for retry, and it is not paused or 'keep_paused' is not provided:
        it will be scheduled immediately (* see 'jitter' flag),

        Flags:

        'jitter': the activity will be scheduled at a random time within the jitter duration.
        If the activity currently paused it will be unpaused, unless 'keep_paused' flag is provided.
        'reset_heartbeats': the activity heartbeat timer and heartbeats will be reset.
        'keep_paused': if the activity is paused, it will remain paused.

        Returns a `NotFound` error if there is no pending activity with the provided ID or type.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def CreateWorkflowRule(self, request, context):
        """Create a new workflow rule. The rules are used to control the workflow execution.
        The rule will be applied to all running and new workflows in the namespace.
        If the rule with such ID already exist this call will fail
        Note: the rules are part of namespace configuration and will be stored in the namespace config.
        Namespace config is eventually consistent.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def DescribeWorkflowRule(self, request, context):
        """DescribeWorkflowRule return the rule specification for existing rule id.
        If there is no rule with such id - NOT FOUND error will be returned.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def DeleteWorkflowRule(self, request, context):
        """Delete rule by rule id"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListWorkflowRules(self, request, context):
        """Return all namespace workflow rules"""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def TriggerWorkflowRule(self, request, context):
        """TriggerWorkflowRule allows to:
        * trigger existing rule for a specific workflow execution;
        * trigger rule for a specific workflow execution without creating a rule;
        This is useful for one-off operations.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def RecordWorkerHeartbeat(self, request, context):
        """WorkerHeartbeat receive heartbeat request from the worker."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def ListWorkers(self, request, context):
        """ListWorkers is a visibility API to list worker status information in a specific namespace."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def UpdateTaskQueueConfig(self, request, context):
        """Updates task queue configuration.
        For the overall queue rate limit: the rate limit set by this api overrides the worker-set rate limit,
        which uncouples the rate limit from the worker lifecycle.
        If the overall queue rate limit is unset, the worker-set rate limit takes effect.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def FetchWorkerConfig(self, request, context):
        """FetchWorkerConfig returns the worker configuration for a specific worker."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")

    def UpdateWorkerConfig(self, request, context):
        """UpdateWorkerConfig updates the worker configuration of one or more workers.
        Can be used to partially update the worker configuration.
        Can be used to update the configuration of multiple workers.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details("Method not implemented!")
        raise NotImplementedError("Method not implemented!")


def add_WorkflowServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
        "RegisterNamespace": grpc.unary_unary_rpc_method_handler(
            servicer.RegisterNamespace,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RegisterNamespaceRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RegisterNamespaceResponse.SerializeToString,
        ),
        "DescribeNamespace": grpc.unary_unary_rpc_method_handler(
            servicer.DescribeNamespace,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeNamespaceRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeNamespaceResponse.SerializeToString,
        ),
        "ListNamespaces": grpc.unary_unary_rpc_method_handler(
            servicer.ListNamespaces,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListNamespacesRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListNamespacesResponse.SerializeToString,
        ),
        "UpdateNamespace": grpc.unary_unary_rpc_method_handler(
            servicer.UpdateNamespace,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateNamespaceRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateNamespaceResponse.SerializeToString,
        ),
        "DeprecateNamespace": grpc.unary_unary_rpc_method_handler(
            servicer.DeprecateNamespace,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeprecateNamespaceRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeprecateNamespaceResponse.SerializeToString,
        ),
        "StartWorkflowExecution": grpc.unary_unary_rpc_method_handler(
            servicer.StartWorkflowExecution,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.StartWorkflowExecutionRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.StartWorkflowExecutionResponse.SerializeToString,
        ),
        "ExecuteMultiOperation": grpc.unary_unary_rpc_method_handler(
            servicer.ExecuteMultiOperation,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ExecuteMultiOperationRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ExecuteMultiOperationResponse.SerializeToString,
        ),
        "GetWorkflowExecutionHistory": grpc.unary_unary_rpc_method_handler(
            servicer.GetWorkflowExecutionHistory,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetWorkflowExecutionHistoryRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetWorkflowExecutionHistoryResponse.SerializeToString,
        ),
        "GetWorkflowExecutionHistoryReverse": grpc.unary_unary_rpc_method_handler(
            servicer.GetWorkflowExecutionHistoryReverse,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetWorkflowExecutionHistoryReverseRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetWorkflowExecutionHistoryReverseResponse.SerializeToString,
        ),
        "PollWorkflowTaskQueue": grpc.unary_unary_rpc_method_handler(
            servicer.PollWorkflowTaskQueue,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PollWorkflowTaskQueueRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PollWorkflowTaskQueueResponse.SerializeToString,
        ),
        "RespondWorkflowTaskCompleted": grpc.unary_unary_rpc_method_handler(
            servicer.RespondWorkflowTaskCompleted,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondWorkflowTaskCompletedRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondWorkflowTaskCompletedResponse.SerializeToString,
        ),
        "RespondWorkflowTaskFailed": grpc.unary_unary_rpc_method_handler(
            servicer.RespondWorkflowTaskFailed,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondWorkflowTaskFailedRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondWorkflowTaskFailedResponse.SerializeToString,
        ),
        "PollActivityTaskQueue": grpc.unary_unary_rpc_method_handler(
            servicer.PollActivityTaskQueue,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PollActivityTaskQueueRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PollActivityTaskQueueResponse.SerializeToString,
        ),
        "RecordActivityTaskHeartbeat": grpc.unary_unary_rpc_method_handler(
            servicer.RecordActivityTaskHeartbeat,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RecordActivityTaskHeartbeatRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RecordActivityTaskHeartbeatResponse.SerializeToString,
        ),
        "RecordActivityTaskHeartbeatById": grpc.unary_unary_rpc_method_handler(
            servicer.RecordActivityTaskHeartbeatById,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RecordActivityTaskHeartbeatByIdRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RecordActivityTaskHeartbeatByIdResponse.SerializeToString,
        ),
        "RespondActivityTaskCompleted": grpc.unary_unary_rpc_method_handler(
            servicer.RespondActivityTaskCompleted,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskCompletedRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskCompletedResponse.SerializeToString,
        ),
        "RespondActivityTaskCompletedById": grpc.unary_unary_rpc_method_handler(
            servicer.RespondActivityTaskCompletedById,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskCompletedByIdRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskCompletedByIdResponse.SerializeToString,
        ),
        "RespondActivityTaskFailed": grpc.unary_unary_rpc_method_handler(
            servicer.RespondActivityTaskFailed,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskFailedRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskFailedResponse.SerializeToString,
        ),
        "RespondActivityTaskFailedById": grpc.unary_unary_rpc_method_handler(
            servicer.RespondActivityTaskFailedById,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskFailedByIdRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskFailedByIdResponse.SerializeToString,
        ),
        "RespondActivityTaskCanceled": grpc.unary_unary_rpc_method_handler(
            servicer.RespondActivityTaskCanceled,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskCanceledRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskCanceledResponse.SerializeToString,
        ),
        "RespondActivityTaskCanceledById": grpc.unary_unary_rpc_method_handler(
            servicer.RespondActivityTaskCanceledById,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskCanceledByIdRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskCanceledByIdResponse.SerializeToString,
        ),
        "RequestCancelWorkflowExecution": grpc.unary_unary_rpc_method_handler(
            servicer.RequestCancelWorkflowExecution,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RequestCancelWorkflowExecutionRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RequestCancelWorkflowExecutionResponse.SerializeToString,
        ),
        "SignalWorkflowExecution": grpc.unary_unary_rpc_method_handler(
            servicer.SignalWorkflowExecution,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.SignalWorkflowExecutionRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.SignalWorkflowExecutionResponse.SerializeToString,
        ),
        "SignalWithStartWorkflowExecution": grpc.unary_unary_rpc_method_handler(
            servicer.SignalWithStartWorkflowExecution,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.SignalWithStartWorkflowExecutionRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.SignalWithStartWorkflowExecutionResponse.SerializeToString,
        ),
        "ResetWorkflowExecution": grpc.unary_unary_rpc_method_handler(
            servicer.ResetWorkflowExecution,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ResetWorkflowExecutionRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ResetWorkflowExecutionResponse.SerializeToString,
        ),
        "TerminateWorkflowExecution": grpc.unary_unary_rpc_method_handler(
            servicer.TerminateWorkflowExecution,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.TerminateWorkflowExecutionRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.TerminateWorkflowExecutionResponse.SerializeToString,
        ),
        "DeleteWorkflowExecution": grpc.unary_unary_rpc_method_handler(
            servicer.DeleteWorkflowExecution,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteWorkflowExecutionRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteWorkflowExecutionResponse.SerializeToString,
        ),
        "ListOpenWorkflowExecutions": grpc.unary_unary_rpc_method_handler(
            servicer.ListOpenWorkflowExecutions,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListOpenWorkflowExecutionsRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListOpenWorkflowExecutionsResponse.SerializeToString,
        ),
        "ListClosedWorkflowExecutions": grpc.unary_unary_rpc_method_handler(
            servicer.ListClosedWorkflowExecutions,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListClosedWorkflowExecutionsRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListClosedWorkflowExecutionsResponse.SerializeToString,
        ),
        "ListWorkflowExecutions": grpc.unary_unary_rpc_method_handler(
            servicer.ListWorkflowExecutions,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListWorkflowExecutionsRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListWorkflowExecutionsResponse.SerializeToString,
        ),
        "ListArchivedWorkflowExecutions": grpc.unary_unary_rpc_method_handler(
            servicer.ListArchivedWorkflowExecutions,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListArchivedWorkflowExecutionsRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListArchivedWorkflowExecutionsResponse.SerializeToString,
        ),
        "ScanWorkflowExecutions": grpc.unary_unary_rpc_method_handler(
            servicer.ScanWorkflowExecutions,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ScanWorkflowExecutionsRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ScanWorkflowExecutionsResponse.SerializeToString,
        ),
        "CountWorkflowExecutions": grpc.unary_unary_rpc_method_handler(
            servicer.CountWorkflowExecutions,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.CountWorkflowExecutionsRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.CountWorkflowExecutionsResponse.SerializeToString,
        ),
        "GetSearchAttributes": grpc.unary_unary_rpc_method_handler(
            servicer.GetSearchAttributes,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetSearchAttributesRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetSearchAttributesResponse.SerializeToString,
        ),
        "RespondQueryTaskCompleted": grpc.unary_unary_rpc_method_handler(
            servicer.RespondQueryTaskCompleted,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondQueryTaskCompletedRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondQueryTaskCompletedResponse.SerializeToString,
        ),
        "ResetStickyTaskQueue": grpc.unary_unary_rpc_method_handler(
            servicer.ResetStickyTaskQueue,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ResetStickyTaskQueueRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ResetStickyTaskQueueResponse.SerializeToString,
        ),
        "ShutdownWorker": grpc.unary_unary_rpc_method_handler(
            servicer.ShutdownWorker,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ShutdownWorkerRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ShutdownWorkerResponse.SerializeToString,
        ),
        "QueryWorkflow": grpc.unary_unary_rpc_method_handler(
            servicer.QueryWorkflow,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.QueryWorkflowRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.QueryWorkflowResponse.SerializeToString,
        ),
        "DescribeWorkflowExecution": grpc.unary_unary_rpc_method_handler(
            servicer.DescribeWorkflowExecution,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeWorkflowExecutionRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeWorkflowExecutionResponse.SerializeToString,
        ),
        "DescribeTaskQueue": grpc.unary_unary_rpc_method_handler(
            servicer.DescribeTaskQueue,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeTaskQueueRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeTaskQueueResponse.SerializeToString,
        ),
        "GetClusterInfo": grpc.unary_unary_rpc_method_handler(
            servicer.GetClusterInfo,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetClusterInfoRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetClusterInfoResponse.SerializeToString,
        ),
        "GetSystemInfo": grpc.unary_unary_rpc_method_handler(
            servicer.GetSystemInfo,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetSystemInfoRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetSystemInfoResponse.SerializeToString,
        ),
        "ListTaskQueuePartitions": grpc.unary_unary_rpc_method_handler(
            servicer.ListTaskQueuePartitions,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListTaskQueuePartitionsRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListTaskQueuePartitionsResponse.SerializeToString,
        ),
        "CreateSchedule": grpc.unary_unary_rpc_method_handler(
            servicer.CreateSchedule,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.CreateScheduleRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.CreateScheduleResponse.SerializeToString,
        ),
        "DescribeSchedule": grpc.unary_unary_rpc_method_handler(
            servicer.DescribeSchedule,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeScheduleRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeScheduleResponse.SerializeToString,
        ),
        "UpdateSchedule": grpc.unary_unary_rpc_method_handler(
            servicer.UpdateSchedule,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateScheduleRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateScheduleResponse.SerializeToString,
        ),
        "PatchSchedule": grpc.unary_unary_rpc_method_handler(
            servicer.PatchSchedule,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PatchScheduleRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PatchScheduleResponse.SerializeToString,
        ),
        "ListScheduleMatchingTimes": grpc.unary_unary_rpc_method_handler(
            servicer.ListScheduleMatchingTimes,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListScheduleMatchingTimesRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListScheduleMatchingTimesResponse.SerializeToString,
        ),
        "DeleteSchedule": grpc.unary_unary_rpc_method_handler(
            servicer.DeleteSchedule,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteScheduleRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteScheduleResponse.SerializeToString,
        ),
        "ListSchedules": grpc.unary_unary_rpc_method_handler(
            servicer.ListSchedules,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListSchedulesRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListSchedulesResponse.SerializeToString,
        ),
        "UpdateWorkerBuildIdCompatibility": grpc.unary_unary_rpc_method_handler(
            servicer.UpdateWorkerBuildIdCompatibility,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkerBuildIdCompatibilityRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkerBuildIdCompatibilityResponse.SerializeToString,
        ),
        "GetWorkerBuildIdCompatibility": grpc.unary_unary_rpc_method_handler(
            servicer.GetWorkerBuildIdCompatibility,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetWorkerBuildIdCompatibilityRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetWorkerBuildIdCompatibilityResponse.SerializeToString,
        ),
        "UpdateWorkerVersioningRules": grpc.unary_unary_rpc_method_handler(
            servicer.UpdateWorkerVersioningRules,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkerVersioningRulesRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkerVersioningRulesResponse.SerializeToString,
        ),
        "GetWorkerVersioningRules": grpc.unary_unary_rpc_method_handler(
            servicer.GetWorkerVersioningRules,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetWorkerVersioningRulesRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetWorkerVersioningRulesResponse.SerializeToString,
        ),
        "GetWorkerTaskReachability": grpc.unary_unary_rpc_method_handler(
            servicer.GetWorkerTaskReachability,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetWorkerTaskReachabilityRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetWorkerTaskReachabilityResponse.SerializeToString,
        ),
        "DescribeDeployment": grpc.unary_unary_rpc_method_handler(
            servicer.DescribeDeployment,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeDeploymentRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeDeploymentResponse.SerializeToString,
        ),
        "DescribeWorkerDeploymentVersion": grpc.unary_unary_rpc_method_handler(
            servicer.DescribeWorkerDeploymentVersion,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeWorkerDeploymentVersionRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeWorkerDeploymentVersionResponse.SerializeToString,
        ),
        "ListDeployments": grpc.unary_unary_rpc_method_handler(
            servicer.ListDeployments,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListDeploymentsRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListDeploymentsResponse.SerializeToString,
        ),
        "GetDeploymentReachability": grpc.unary_unary_rpc_method_handler(
            servicer.GetDeploymentReachability,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetDeploymentReachabilityRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetDeploymentReachabilityResponse.SerializeToString,
        ),
        "GetCurrentDeployment": grpc.unary_unary_rpc_method_handler(
            servicer.GetCurrentDeployment,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetCurrentDeploymentRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetCurrentDeploymentResponse.SerializeToString,
        ),
        "SetCurrentDeployment": grpc.unary_unary_rpc_method_handler(
            servicer.SetCurrentDeployment,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.SetCurrentDeploymentRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.SetCurrentDeploymentResponse.SerializeToString,
        ),
        "SetWorkerDeploymentCurrentVersion": grpc.unary_unary_rpc_method_handler(
            servicer.SetWorkerDeploymentCurrentVersion,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.SetWorkerDeploymentCurrentVersionRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.SetWorkerDeploymentCurrentVersionResponse.SerializeToString,
        ),
        "DescribeWorkerDeployment": grpc.unary_unary_rpc_method_handler(
            servicer.DescribeWorkerDeployment,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeWorkerDeploymentRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeWorkerDeploymentResponse.SerializeToString,
        ),
        "DeleteWorkerDeployment": grpc.unary_unary_rpc_method_handler(
            servicer.DeleteWorkerDeployment,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteWorkerDeploymentRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteWorkerDeploymentResponse.SerializeToString,
        ),
        "DeleteWorkerDeploymentVersion": grpc.unary_unary_rpc_method_handler(
            servicer.DeleteWorkerDeploymentVersion,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteWorkerDeploymentVersionRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteWorkerDeploymentVersionResponse.SerializeToString,
        ),
        "SetWorkerDeploymentRampingVersion": grpc.unary_unary_rpc_method_handler(
            servicer.SetWorkerDeploymentRampingVersion,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.SetWorkerDeploymentRampingVersionRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.SetWorkerDeploymentRampingVersionResponse.SerializeToString,
        ),
        "ListWorkerDeployments": grpc.unary_unary_rpc_method_handler(
            servicer.ListWorkerDeployments,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListWorkerDeploymentsRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListWorkerDeploymentsResponse.SerializeToString,
        ),
        "UpdateWorkerDeploymentVersionMetadata": grpc.unary_unary_rpc_method_handler(
            servicer.UpdateWorkerDeploymentVersionMetadata,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkerDeploymentVersionMetadataRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkerDeploymentVersionMetadataResponse.SerializeToString,
        ),
        "UpdateWorkflowExecution": grpc.unary_unary_rpc_method_handler(
            servicer.UpdateWorkflowExecution,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkflowExecutionRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkflowExecutionResponse.SerializeToString,
        ),
        "PollWorkflowExecutionUpdate": grpc.unary_unary_rpc_method_handler(
            servicer.PollWorkflowExecutionUpdate,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PollWorkflowExecutionUpdateRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PollWorkflowExecutionUpdateResponse.SerializeToString,
        ),
        "StartBatchOperation": grpc.unary_unary_rpc_method_handler(
            servicer.StartBatchOperation,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.StartBatchOperationRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.StartBatchOperationResponse.SerializeToString,
        ),
        "StopBatchOperation": grpc.unary_unary_rpc_method_handler(
            servicer.StopBatchOperation,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.StopBatchOperationRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.StopBatchOperationResponse.SerializeToString,
        ),
        "DescribeBatchOperation": grpc.unary_unary_rpc_method_handler(
            servicer.DescribeBatchOperation,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeBatchOperationRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeBatchOperationResponse.SerializeToString,
        ),
        "ListBatchOperations": grpc.unary_unary_rpc_method_handler(
            servicer.ListBatchOperations,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListBatchOperationsRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListBatchOperationsResponse.SerializeToString,
        ),
        "PollNexusTaskQueue": grpc.unary_unary_rpc_method_handler(
            servicer.PollNexusTaskQueue,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PollNexusTaskQueueRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PollNexusTaskQueueResponse.SerializeToString,
        ),
        "RespondNexusTaskCompleted": grpc.unary_unary_rpc_method_handler(
            servicer.RespondNexusTaskCompleted,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondNexusTaskCompletedRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondNexusTaskCompletedResponse.SerializeToString,
        ),
        "RespondNexusTaskFailed": grpc.unary_unary_rpc_method_handler(
            servicer.RespondNexusTaskFailed,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondNexusTaskFailedRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondNexusTaskFailedResponse.SerializeToString,
        ),
        "UpdateActivityOptions": grpc.unary_unary_rpc_method_handler(
            servicer.UpdateActivityOptions,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateActivityOptionsRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateActivityOptionsResponse.SerializeToString,
        ),
        "UpdateWorkflowExecutionOptions": grpc.unary_unary_rpc_method_handler(
            servicer.UpdateWorkflowExecutionOptions,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkflowExecutionOptionsRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkflowExecutionOptionsResponse.SerializeToString,
        ),
        "PauseActivity": grpc.unary_unary_rpc_method_handler(
            servicer.PauseActivity,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PauseActivityRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PauseActivityResponse.SerializeToString,
        ),
        "UnpauseActivity": grpc.unary_unary_rpc_method_handler(
            servicer.UnpauseActivity,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UnpauseActivityRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UnpauseActivityResponse.SerializeToString,
        ),
        "ResetActivity": grpc.unary_unary_rpc_method_handler(
            servicer.ResetActivity,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ResetActivityRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ResetActivityResponse.SerializeToString,
        ),
        "CreateWorkflowRule": grpc.unary_unary_rpc_method_handler(
            servicer.CreateWorkflowRule,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.CreateWorkflowRuleRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.CreateWorkflowRuleResponse.SerializeToString,
        ),
        "DescribeWorkflowRule": grpc.unary_unary_rpc_method_handler(
            servicer.DescribeWorkflowRule,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeWorkflowRuleRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeWorkflowRuleResponse.SerializeToString,
        ),
        "DeleteWorkflowRule": grpc.unary_unary_rpc_method_handler(
            servicer.DeleteWorkflowRule,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteWorkflowRuleRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteWorkflowRuleResponse.SerializeToString,
        ),
        "ListWorkflowRules": grpc.unary_unary_rpc_method_handler(
            servicer.ListWorkflowRules,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListWorkflowRulesRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListWorkflowRulesResponse.SerializeToString,
        ),
        "TriggerWorkflowRule": grpc.unary_unary_rpc_method_handler(
            servicer.TriggerWorkflowRule,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.TriggerWorkflowRuleRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.TriggerWorkflowRuleResponse.SerializeToString,
        ),
        "RecordWorkerHeartbeat": grpc.unary_unary_rpc_method_handler(
            servicer.RecordWorkerHeartbeat,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RecordWorkerHeartbeatRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RecordWorkerHeartbeatResponse.SerializeToString,
        ),
        "ListWorkers": grpc.unary_unary_rpc_method_handler(
            servicer.ListWorkers,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListWorkersRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListWorkersResponse.SerializeToString,
        ),
        "UpdateTaskQueueConfig": grpc.unary_unary_rpc_method_handler(
            servicer.UpdateTaskQueueConfig,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateTaskQueueConfigRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateTaskQueueConfigResponse.SerializeToString,
        ),
        "FetchWorkerConfig": grpc.unary_unary_rpc_method_handler(
            servicer.FetchWorkerConfig,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.FetchWorkerConfigRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.FetchWorkerConfigResponse.SerializeToString,
        ),
        "UpdateWorkerConfig": grpc.unary_unary_rpc_method_handler(
            servicer.UpdateWorkerConfig,
            request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkerConfigRequest.FromString,
            response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkerConfigResponse.SerializeToString,
        ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
        "temporal.api.workflowservice.v1.WorkflowService", rpc_method_handlers
    )
    server.add_generic_rpc_handlers((generic_handler,))


# This class is part of an EXPERIMENTAL API.
class WorkflowService(object):
    """WorkflowService API defines how Temporal SDKs and other clients interact with the Temporal server
    to create and interact with workflows and activities.

    Users are expected to call `StartWorkflowExecution` to create a new workflow execution.

    To drive workflows, a worker using a Temporal SDK must exist which regularly polls for workflow
    and activity tasks from the service. For each workflow task, the sdk must process the
    (incremental or complete) event history and respond back with any newly generated commands.

    For each activity task, the worker is expected to execute the user's code which implements that
    activity, responding with completion or failure.
    """

    @staticmethod
    def RegisterNamespace(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/RegisterNamespace",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RegisterNamespaceRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RegisterNamespaceResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def DescribeNamespace(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/DescribeNamespace",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeNamespaceRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeNamespaceResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListNamespaces(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/ListNamespaces",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListNamespacesRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListNamespacesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def UpdateNamespace(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/UpdateNamespace",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateNamespaceRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateNamespaceResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def DeprecateNamespace(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/DeprecateNamespace",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeprecateNamespaceRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeprecateNamespaceResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def StartWorkflowExecution(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/StartWorkflowExecution",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.StartWorkflowExecutionRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.StartWorkflowExecutionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ExecuteMultiOperation(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/ExecuteMultiOperation",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ExecuteMultiOperationRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ExecuteMultiOperationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetWorkflowExecutionHistory(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/GetWorkflowExecutionHistory",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetWorkflowExecutionHistoryRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetWorkflowExecutionHistoryResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetWorkflowExecutionHistoryReverse(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/GetWorkflowExecutionHistoryReverse",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetWorkflowExecutionHistoryReverseRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetWorkflowExecutionHistoryReverseResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def PollWorkflowTaskQueue(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/PollWorkflowTaskQueue",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PollWorkflowTaskQueueRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PollWorkflowTaskQueueResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def RespondWorkflowTaskCompleted(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/RespondWorkflowTaskCompleted",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondWorkflowTaskCompletedRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondWorkflowTaskCompletedResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def RespondWorkflowTaskFailed(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/RespondWorkflowTaskFailed",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondWorkflowTaskFailedRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondWorkflowTaskFailedResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def PollActivityTaskQueue(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/PollActivityTaskQueue",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PollActivityTaskQueueRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PollActivityTaskQueueResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def RecordActivityTaskHeartbeat(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/RecordActivityTaskHeartbeat",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RecordActivityTaskHeartbeatRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RecordActivityTaskHeartbeatResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def RecordActivityTaskHeartbeatById(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/RecordActivityTaskHeartbeatById",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RecordActivityTaskHeartbeatByIdRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RecordActivityTaskHeartbeatByIdResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def RespondActivityTaskCompleted(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/RespondActivityTaskCompleted",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskCompletedRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskCompletedResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def RespondActivityTaskCompletedById(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/RespondActivityTaskCompletedById",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskCompletedByIdRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskCompletedByIdResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def RespondActivityTaskFailed(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/RespondActivityTaskFailed",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskFailedRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskFailedResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def RespondActivityTaskFailedById(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/RespondActivityTaskFailedById",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskFailedByIdRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskFailedByIdResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def RespondActivityTaskCanceled(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/RespondActivityTaskCanceled",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskCanceledRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskCanceledResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def RespondActivityTaskCanceledById(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/RespondActivityTaskCanceledById",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskCanceledByIdRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondActivityTaskCanceledByIdResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def RequestCancelWorkflowExecution(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/RequestCancelWorkflowExecution",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RequestCancelWorkflowExecutionRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RequestCancelWorkflowExecutionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def SignalWorkflowExecution(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/SignalWorkflowExecution",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.SignalWorkflowExecutionRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.SignalWorkflowExecutionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def SignalWithStartWorkflowExecution(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/SignalWithStartWorkflowExecution",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.SignalWithStartWorkflowExecutionRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.SignalWithStartWorkflowExecutionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ResetWorkflowExecution(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/ResetWorkflowExecution",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ResetWorkflowExecutionRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ResetWorkflowExecutionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def TerminateWorkflowExecution(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/TerminateWorkflowExecution",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.TerminateWorkflowExecutionRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.TerminateWorkflowExecutionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def DeleteWorkflowExecution(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/DeleteWorkflowExecution",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteWorkflowExecutionRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteWorkflowExecutionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListOpenWorkflowExecutions(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/ListOpenWorkflowExecutions",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListOpenWorkflowExecutionsRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListOpenWorkflowExecutionsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListClosedWorkflowExecutions(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/ListClosedWorkflowExecutions",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListClosedWorkflowExecutionsRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListClosedWorkflowExecutionsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListWorkflowExecutions(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/ListWorkflowExecutions",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListWorkflowExecutionsRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListWorkflowExecutionsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListArchivedWorkflowExecutions(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/ListArchivedWorkflowExecutions",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListArchivedWorkflowExecutionsRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListArchivedWorkflowExecutionsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ScanWorkflowExecutions(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/ScanWorkflowExecutions",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ScanWorkflowExecutionsRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ScanWorkflowExecutionsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def CountWorkflowExecutions(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/CountWorkflowExecutions",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.CountWorkflowExecutionsRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.CountWorkflowExecutionsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetSearchAttributes(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/GetSearchAttributes",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetSearchAttributesRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetSearchAttributesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def RespondQueryTaskCompleted(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/RespondQueryTaskCompleted",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondQueryTaskCompletedRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondQueryTaskCompletedResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ResetStickyTaskQueue(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/ResetStickyTaskQueue",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ResetStickyTaskQueueRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ResetStickyTaskQueueResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ShutdownWorker(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/ShutdownWorker",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ShutdownWorkerRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ShutdownWorkerResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def QueryWorkflow(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/QueryWorkflow",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.QueryWorkflowRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.QueryWorkflowResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def DescribeWorkflowExecution(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/DescribeWorkflowExecution",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeWorkflowExecutionRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeWorkflowExecutionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def DescribeTaskQueue(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/DescribeTaskQueue",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeTaskQueueRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeTaskQueueResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetClusterInfo(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/GetClusterInfo",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetClusterInfoRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetClusterInfoResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetSystemInfo(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/GetSystemInfo",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetSystemInfoRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetSystemInfoResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListTaskQueuePartitions(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/ListTaskQueuePartitions",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListTaskQueuePartitionsRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListTaskQueuePartitionsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def CreateSchedule(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/CreateSchedule",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.CreateScheduleRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.CreateScheduleResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def DescribeSchedule(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/DescribeSchedule",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeScheduleRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeScheduleResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def UpdateSchedule(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/UpdateSchedule",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateScheduleRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateScheduleResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def PatchSchedule(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/PatchSchedule",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PatchScheduleRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PatchScheduleResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListScheduleMatchingTimes(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/ListScheduleMatchingTimes",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListScheduleMatchingTimesRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListScheduleMatchingTimesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def DeleteSchedule(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/DeleteSchedule",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteScheduleRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteScheduleResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListSchedules(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/ListSchedules",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListSchedulesRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListSchedulesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def UpdateWorkerBuildIdCompatibility(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/UpdateWorkerBuildIdCompatibility",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkerBuildIdCompatibilityRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkerBuildIdCompatibilityResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetWorkerBuildIdCompatibility(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/GetWorkerBuildIdCompatibility",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetWorkerBuildIdCompatibilityRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetWorkerBuildIdCompatibilityResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def UpdateWorkerVersioningRules(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/UpdateWorkerVersioningRules",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkerVersioningRulesRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkerVersioningRulesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetWorkerVersioningRules(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/GetWorkerVersioningRules",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetWorkerVersioningRulesRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetWorkerVersioningRulesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetWorkerTaskReachability(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/GetWorkerTaskReachability",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetWorkerTaskReachabilityRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetWorkerTaskReachabilityResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def DescribeDeployment(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/DescribeDeployment",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeDeploymentRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeDeploymentResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def DescribeWorkerDeploymentVersion(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/DescribeWorkerDeploymentVersion",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeWorkerDeploymentVersionRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeWorkerDeploymentVersionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListDeployments(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/ListDeployments",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListDeploymentsRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListDeploymentsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetDeploymentReachability(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/GetDeploymentReachability",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetDeploymentReachabilityRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetDeploymentReachabilityResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def GetCurrentDeployment(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/GetCurrentDeployment",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetCurrentDeploymentRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.GetCurrentDeploymentResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def SetCurrentDeployment(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/SetCurrentDeployment",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.SetCurrentDeploymentRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.SetCurrentDeploymentResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def SetWorkerDeploymentCurrentVersion(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/SetWorkerDeploymentCurrentVersion",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.SetWorkerDeploymentCurrentVersionRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.SetWorkerDeploymentCurrentVersionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def DescribeWorkerDeployment(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/DescribeWorkerDeployment",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeWorkerDeploymentRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeWorkerDeploymentResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def DeleteWorkerDeployment(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/DeleteWorkerDeployment",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteWorkerDeploymentRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteWorkerDeploymentResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def DeleteWorkerDeploymentVersion(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/DeleteWorkerDeploymentVersion",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteWorkerDeploymentVersionRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteWorkerDeploymentVersionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def SetWorkerDeploymentRampingVersion(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/SetWorkerDeploymentRampingVersion",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.SetWorkerDeploymentRampingVersionRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.SetWorkerDeploymentRampingVersionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListWorkerDeployments(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/ListWorkerDeployments",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListWorkerDeploymentsRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListWorkerDeploymentsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def UpdateWorkerDeploymentVersionMetadata(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/UpdateWorkerDeploymentVersionMetadata",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkerDeploymentVersionMetadataRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkerDeploymentVersionMetadataResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def UpdateWorkflowExecution(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/UpdateWorkflowExecution",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkflowExecutionRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkflowExecutionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def PollWorkflowExecutionUpdate(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/PollWorkflowExecutionUpdate",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PollWorkflowExecutionUpdateRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PollWorkflowExecutionUpdateResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def StartBatchOperation(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/StartBatchOperation",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.StartBatchOperationRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.StartBatchOperationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def StopBatchOperation(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/StopBatchOperation",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.StopBatchOperationRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.StopBatchOperationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def DescribeBatchOperation(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/DescribeBatchOperation",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeBatchOperationRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeBatchOperationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListBatchOperations(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/ListBatchOperations",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListBatchOperationsRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListBatchOperationsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def PollNexusTaskQueue(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/PollNexusTaskQueue",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PollNexusTaskQueueRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PollNexusTaskQueueResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def RespondNexusTaskCompleted(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/RespondNexusTaskCompleted",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondNexusTaskCompletedRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondNexusTaskCompletedResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def RespondNexusTaskFailed(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/RespondNexusTaskFailed",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondNexusTaskFailedRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RespondNexusTaskFailedResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def UpdateActivityOptions(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/UpdateActivityOptions",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateActivityOptionsRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateActivityOptionsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def UpdateWorkflowExecutionOptions(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/UpdateWorkflowExecutionOptions",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkflowExecutionOptionsRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkflowExecutionOptionsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def PauseActivity(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/PauseActivity",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PauseActivityRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PauseActivityResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def UnpauseActivity(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/UnpauseActivity",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UnpauseActivityRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UnpauseActivityResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ResetActivity(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/ResetActivity",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ResetActivityRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ResetActivityResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def CreateWorkflowRule(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/CreateWorkflowRule",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.CreateWorkflowRuleRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.CreateWorkflowRuleResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def DescribeWorkflowRule(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/DescribeWorkflowRule",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeWorkflowRuleRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeWorkflowRuleResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def DeleteWorkflowRule(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/DeleteWorkflowRule",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteWorkflowRuleRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteWorkflowRuleResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListWorkflowRules(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/ListWorkflowRules",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListWorkflowRulesRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListWorkflowRulesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def TriggerWorkflowRule(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/TriggerWorkflowRule",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.TriggerWorkflowRuleRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.TriggerWorkflowRuleResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def RecordWorkerHeartbeat(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/RecordWorkerHeartbeat",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RecordWorkerHeartbeatRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RecordWorkerHeartbeatResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def ListWorkers(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/ListWorkers",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListWorkersRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListWorkersResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def UpdateTaskQueueConfig(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/UpdateTaskQueueConfig",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateTaskQueueConfigRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateTaskQueueConfigResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def FetchWorkerConfig(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/FetchWorkerConfig",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.FetchWorkerConfigRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.FetchWorkerConfigResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )

    @staticmethod
    def UpdateWorkerConfig(
        request,
        target,
        options=(),
        channel_credentials=None,
        call_credentials=None,
        insecure=False,
        compression=None,
        wait_for_ready=None,
        timeout=None,
        metadata=None,
    ):
        return grpc.experimental.unary_unary(
            request,
            target,
            "/temporal.api.workflowservice.v1.WorkflowService/UpdateWorkerConfig",
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkerConfigRequest.SerializeToString,
            temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.UpdateWorkerConfigResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
        )
