#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RegisterNamespaceRequest {
    #[prost(string, tag = "1")]
    pub namespace: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub owner_email: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "4")]
    pub workflow_execution_retention_period: ::core::option::Option<::prost_types::Duration>,
    #[prost(message, repeated, tag = "5")]
    pub clusters: ::prost::alloc::vec::Vec<super::super::replication::v1::ClusterReplicationConfig>,
    #[prost(string, tag = "6")]
    pub active_cluster_name: ::prost::alloc::string::String,
    /// A key-value map for any customized purpose.
    #[prost(map = "string, string", tag = "7")]
    pub data:
        ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    #[prost(string, tag = "8")]
    pub security_token: ::prost::alloc::string::String,
    #[prost(bool, tag = "9")]
    pub is_global_namespace: bool,
    /// If unspecified (ARCHIVAL_STATE_UNSPECIFIED) then default server configuration is used.
    #[prost(enumeration = "super::super::enums::v1::ArchivalState", tag = "10")]
    pub history_archival_state: i32,
    #[prost(string, tag = "11")]
    pub history_archival_uri: ::prost::alloc::string::String,
    /// If unspecified (ARCHIVAL_STATE_UNSPECIFIED) then default server configuration is used.
    #[prost(enumeration = "super::super::enums::v1::ArchivalState", tag = "12")]
    pub visibility_archival_state: i32,
    #[prost(string, tag = "13")]
    pub visibility_archival_uri: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RegisterNamespaceResponse {}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListNamespacesRequest {
    #[prost(int32, tag = "1")]
    pub page_size: i32,
    #[prost(bytes = "vec", tag = "2")]
    pub next_page_token: ::prost::alloc::vec::Vec<u8>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListNamespacesResponse {
    #[prost(message, repeated, tag = "1")]
    pub namespaces: ::prost::alloc::vec::Vec<DescribeNamespaceResponse>,
    #[prost(bytes = "vec", tag = "2")]
    pub next_page_token: ::prost::alloc::vec::Vec<u8>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DescribeNamespaceRequest {
    #[prost(string, tag = "1")]
    pub namespace: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub id: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DescribeNamespaceResponse {
    #[prost(message, optional, tag = "1")]
    pub namespace_info: ::core::option::Option<super::super::namespace::v1::NamespaceInfo>,
    #[prost(message, optional, tag = "2")]
    pub config: ::core::option::Option<super::super::namespace::v1::NamespaceConfig>,
    #[prost(message, optional, tag = "3")]
    pub replication_config:
        ::core::option::Option<super::super::replication::v1::NamespaceReplicationConfig>,
    #[prost(int64, tag = "4")]
    pub failover_version: i64,
    #[prost(bool, tag = "5")]
    pub is_global_namespace: bool,
}
/// (-- api-linter: core::0134::request-mask-required=disabled
///     aip.dev/not-precedent: UpdateNamespace RPC doesn't follow Google API format. --)
/// (-- api-linter: core::0134::request-resource-required=disabled
///     aip.dev/not-precedent: UpdateNamespace RPC doesn't follow Google API format. --)
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateNamespaceRequest {
    #[prost(string, tag = "1")]
    pub namespace: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub update_info: ::core::option::Option<super::super::namespace::v1::UpdateNamespaceInfo>,
    #[prost(message, optional, tag = "3")]
    pub config: ::core::option::Option<super::super::namespace::v1::NamespaceConfig>,
    #[prost(message, optional, tag = "4")]
    pub replication_config:
        ::core::option::Option<super::super::replication::v1::NamespaceReplicationConfig>,
    #[prost(string, tag = "5")]
    pub security_token: ::prost::alloc::string::String,
    #[prost(string, tag = "6")]
    pub delete_bad_binary: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateNamespaceResponse {
    #[prost(message, optional, tag = "1")]
    pub namespace_info: ::core::option::Option<super::super::namespace::v1::NamespaceInfo>,
    #[prost(message, optional, tag = "2")]
    pub config: ::core::option::Option<super::super::namespace::v1::NamespaceConfig>,
    #[prost(message, optional, tag = "3")]
    pub replication_config:
        ::core::option::Option<super::super::replication::v1::NamespaceReplicationConfig>,
    #[prost(int64, tag = "4")]
    pub failover_version: i64,
    #[prost(bool, tag = "5")]
    pub is_global_namespace: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeprecateNamespaceRequest {
    #[prost(string, tag = "1")]
    pub namespace: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub security_token: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeprecateNamespaceResponse {}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StartWorkflowExecutionRequest {
    #[prost(string, tag = "1")]
    pub namespace: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub workflow_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub workflow_type: ::core::option::Option<super::super::common::v1::WorkflowType>,
    #[prost(message, optional, tag = "4")]
    pub task_queue: ::core::option::Option<super::super::taskqueue::v1::TaskQueue>,
    #[prost(message, optional, tag = "5")]
    pub input: ::core::option::Option<super::super::common::v1::Payloads>,
    /// Total workflow execution timeout including retries and continue as new.
    #[prost(message, optional, tag = "6")]
    pub workflow_execution_timeout: ::core::option::Option<::prost_types::Duration>,
    /// Timeout of a single workflow run.
    #[prost(message, optional, tag = "7")]
    pub workflow_run_timeout: ::core::option::Option<::prost_types::Duration>,
    /// Timeout of a single workflow task.
    #[prost(message, optional, tag = "8")]
    pub workflow_task_timeout: ::core::option::Option<::prost_types::Duration>,
    #[prost(string, tag = "9")]
    pub identity: ::prost::alloc::string::String,
    #[prost(string, tag = "10")]
    pub request_id: ::prost::alloc::string::String,
    /// Default: WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE.
    #[prost(
        enumeration = "super::super::enums::v1::WorkflowIdReusePolicy",
        tag = "11"
    )]
    pub workflow_id_reuse_policy: i32,
    /// Retries up to workflow_execution_timeout_seconds.
    #[prost(message, optional, tag = "12")]
    pub retry_policy: ::core::option::Option<super::super::common::v1::RetryPolicy>,
    #[prost(string, tag = "13")]
    pub cron_schedule: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "14")]
    pub memo: ::core::option::Option<super::super::common::v1::Memo>,
    #[prost(message, optional, tag = "15")]
    pub search_attributes: ::core::option::Option<super::super::common::v1::SearchAttributes>,
    #[prost(message, optional, tag = "16")]
    pub header: ::core::option::Option<super::super::common::v1::Header>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StartWorkflowExecutionResponse {
    #[prost(string, tag = "1")]
    pub run_id: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetWorkflowExecutionHistoryRequest {
    #[prost(string, tag = "1")]
    pub namespace: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub execution: ::core::option::Option<super::super::common::v1::WorkflowExecution>,
    #[prost(int32, tag = "3")]
    pub maximum_page_size: i32,
    #[prost(bytes = "vec", tag = "4")]
    pub next_page_token: ::prost::alloc::vec::Vec<u8>,
    #[prost(bool, tag = "5")]
    pub wait_new_event: bool,
    /// Default: HISTORY_EVENT_FILTER_TYPE_ALL_EVENT.
    #[prost(
        enumeration = "super::super::enums::v1::HistoryEventFilterType",
        tag = "6"
    )]
    pub history_event_filter_type: i32,
    #[prost(bool, tag = "7")]
    pub skip_archival: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetWorkflowExecutionHistoryResponse {
    #[prost(message, optional, tag = "1")]
    pub history: ::core::option::Option<super::super::history::v1::History>,
    #[prost(message, repeated, tag = "2")]
    pub raw_history: ::prost::alloc::vec::Vec<super::super::common::v1::DataBlob>,
    #[prost(bytes = "vec", tag = "3")]
    pub next_page_token: ::prost::alloc::vec::Vec<u8>,
    #[prost(bool, tag = "4")]
    pub archived: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PollWorkflowTaskQueueRequest {
    #[prost(string, tag = "1")]
    pub namespace: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub task_queue: ::core::option::Option<super::super::taskqueue::v1::TaskQueue>,
    #[prost(string, tag = "3")]
    pub identity: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub binary_checksum: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PollWorkflowTaskQueueResponse {
    #[prost(bytes = "vec", tag = "1")]
    pub task_token: ::prost::alloc::vec::Vec<u8>,
    #[prost(message, optional, tag = "2")]
    pub workflow_execution: ::core::option::Option<super::super::common::v1::WorkflowExecution>,
    #[prost(message, optional, tag = "3")]
    pub workflow_type: ::core::option::Option<super::super::common::v1::WorkflowType>,
    #[prost(int64, tag = "4")]
    pub previous_started_event_id: i64,
    #[prost(int64, tag = "5")]
    pub started_event_id: i64,
    #[prost(int32, tag = "6")]
    pub attempt: i32,
    #[prost(int64, tag = "7")]
    pub backlog_count_hint: i64,
    #[prost(message, optional, tag = "8")]
    pub history: ::core::option::Option<super::super::history::v1::History>,
    #[prost(bytes = "vec", tag = "9")]
    pub next_page_token: ::prost::alloc::vec::Vec<u8>,
    #[prost(message, optional, tag = "10")]
    pub query: ::core::option::Option<super::super::query::v1::WorkflowQuery>,
    #[prost(message, optional, tag = "11")]
    pub workflow_execution_task_queue:
        ::core::option::Option<super::super::taskqueue::v1::TaskQueue>,
    #[prost(message, optional, tag = "12")]
    pub scheduled_time: ::core::option::Option<::prost_types::Timestamp>,
    #[prost(message, optional, tag = "13")]
    pub started_time: ::core::option::Option<::prost_types::Timestamp>,
    #[prost(map = "string, message", tag = "14")]
    pub queries: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        super::super::query::v1::WorkflowQuery,
    >,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RespondWorkflowTaskCompletedRequest {
    #[prost(bytes = "vec", tag = "1")]
    pub task_token: ::prost::alloc::vec::Vec<u8>,
    #[prost(message, repeated, tag = "2")]
    pub commands: ::prost::alloc::vec::Vec<super::super::command::v1::Command>,
    #[prost(string, tag = "3")]
    pub identity: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "4")]
    pub sticky_attributes:
        ::core::option::Option<super::super::taskqueue::v1::StickyExecutionAttributes>,
    #[prost(bool, tag = "5")]
    pub return_new_workflow_task: bool,
    #[prost(bool, tag = "6")]
    pub force_create_new_workflow_task: bool,
    #[prost(string, tag = "7")]
    pub binary_checksum: ::prost::alloc::string::String,
    #[prost(map = "string, message", tag = "8")]
    pub query_results: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        super::super::query::v1::WorkflowQueryResult,
    >,
    #[prost(string, tag = "9")]
    pub namespace: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RespondWorkflowTaskCompletedResponse {
    #[prost(message, optional, tag = "1")]
    pub workflow_task: ::core::option::Option<PollWorkflowTaskQueueResponse>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RespondWorkflowTaskFailedRequest {
    #[prost(bytes = "vec", tag = "1")]
    pub task_token: ::prost::alloc::vec::Vec<u8>,
    #[prost(
        enumeration = "super::super::enums::v1::WorkflowTaskFailedCause",
        tag = "2"
    )]
    pub cause: i32,
    #[prost(message, optional, tag = "3")]
    pub failure: ::core::option::Option<super::super::failure::v1::Failure>,
    #[prost(string, tag = "4")]
    pub identity: ::prost::alloc::string::String,
    #[prost(string, tag = "5")]
    pub binary_checksum: ::prost::alloc::string::String,
    #[prost(string, tag = "6")]
    pub namespace: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RespondWorkflowTaskFailedResponse {}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PollActivityTaskQueueRequest {
    #[prost(string, tag = "1")]
    pub namespace: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub task_queue: ::core::option::Option<super::super::taskqueue::v1::TaskQueue>,
    #[prost(string, tag = "3")]
    pub identity: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "4")]
    pub task_queue_metadata: ::core::option::Option<super::super::taskqueue::v1::TaskQueueMetadata>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PollActivityTaskQueueResponse {
    #[prost(bytes = "vec", tag = "1")]
    pub task_token: ::prost::alloc::vec::Vec<u8>,
    #[prost(string, tag = "2")]
    pub workflow_namespace: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub workflow_type: ::core::option::Option<super::super::common::v1::WorkflowType>,
    #[prost(message, optional, tag = "4")]
    pub workflow_execution: ::core::option::Option<super::super::common::v1::WorkflowExecution>,
    #[prost(message, optional, tag = "5")]
    pub activity_type: ::core::option::Option<super::super::common::v1::ActivityType>,
    #[prost(string, tag = "6")]
    pub activity_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "7")]
    pub header: ::core::option::Option<super::super::common::v1::Header>,
    #[prost(message, optional, tag = "8")]
    pub input: ::core::option::Option<super::super::common::v1::Payloads>,
    #[prost(message, optional, tag = "9")]
    pub heartbeat_details: ::core::option::Option<super::super::common::v1::Payloads>,
    #[prost(message, optional, tag = "10")]
    pub scheduled_time: ::core::option::Option<::prost_types::Timestamp>,
    #[prost(message, optional, tag = "11")]
    pub current_attempt_scheduled_time: ::core::option::Option<::prost_types::Timestamp>,
    #[prost(message, optional, tag = "12")]
    pub started_time: ::core::option::Option<::prost_types::Timestamp>,
    #[prost(int32, tag = "13")]
    pub attempt: i32,
    /// (-- api-linter: core::0140::prepositions=disabled
    ///     aip.dev/not-precedent: "to" is used to indicate interval. --)
    #[prost(message, optional, tag = "14")]
    pub schedule_to_close_timeout: ::core::option::Option<::prost_types::Duration>,
    /// (-- api-linter: core::0140::prepositions=disabled
    ///     aip.dev/not-precedent: "to" is used to indicate interval. --)
    #[prost(message, optional, tag = "15")]
    pub start_to_close_timeout: ::core::option::Option<::prost_types::Duration>,
    #[prost(message, optional, tag = "16")]
    pub heartbeat_timeout: ::core::option::Option<::prost_types::Duration>,
    /// This is an actual retry policy the service uses.
    /// It can be different from the one provided (or not) during activity scheduling
    /// as the service can override the provided one in case its values are not specified
    /// or exceed configured system limits.
    #[prost(message, optional, tag = "17")]
    pub retry_policy: ::core::option::Option<super::super::common::v1::RetryPolicy>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RecordActivityTaskHeartbeatRequest {
    #[prost(bytes = "vec", tag = "1")]
    pub task_token: ::prost::alloc::vec::Vec<u8>,
    #[prost(message, optional, tag = "2")]
    pub details: ::core::option::Option<super::super::common::v1::Payloads>,
    #[prost(string, tag = "3")]
    pub identity: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub namespace: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RecordActivityTaskHeartbeatResponse {
    #[prost(bool, tag = "1")]
    pub cancel_requested: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RecordActivityTaskHeartbeatByIdRequest {
    #[prost(string, tag = "1")]
    pub namespace: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub workflow_id: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub run_id: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub activity_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "5")]
    pub details: ::core::option::Option<super::super::common::v1::Payloads>,
    #[prost(string, tag = "6")]
    pub identity: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RecordActivityTaskHeartbeatByIdResponse {
    #[prost(bool, tag = "1")]
    pub cancel_requested: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RespondActivityTaskCompletedRequest {
    #[prost(bytes = "vec", tag = "1")]
    pub task_token: ::prost::alloc::vec::Vec<u8>,
    #[prost(message, optional, tag = "2")]
    pub result: ::core::option::Option<super::super::common::v1::Payloads>,
    #[prost(string, tag = "3")]
    pub identity: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub namespace: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RespondActivityTaskCompletedResponse {}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RespondActivityTaskCompletedByIdRequest {
    #[prost(string, tag = "1")]
    pub namespace: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub workflow_id: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub run_id: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub activity_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "5")]
    pub result: ::core::option::Option<super::super::common::v1::Payloads>,
    #[prost(string, tag = "6")]
    pub identity: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RespondActivityTaskCompletedByIdResponse {}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RespondActivityTaskFailedRequest {
    #[prost(bytes = "vec", tag = "1")]
    pub task_token: ::prost::alloc::vec::Vec<u8>,
    #[prost(message, optional, tag = "2")]
    pub failure: ::core::option::Option<super::super::failure::v1::Failure>,
    #[prost(string, tag = "3")]
    pub identity: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub namespace: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RespondActivityTaskFailedResponse {}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RespondActivityTaskFailedByIdRequest {
    #[prost(string, tag = "1")]
    pub namespace: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub workflow_id: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub run_id: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub activity_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "5")]
    pub failure: ::core::option::Option<super::super::failure::v1::Failure>,
    #[prost(string, tag = "6")]
    pub identity: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RespondActivityTaskFailedByIdResponse {}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RespondActivityTaskCanceledRequest {
    #[prost(bytes = "vec", tag = "1")]
    pub task_token: ::prost::alloc::vec::Vec<u8>,
    #[prost(message, optional, tag = "2")]
    pub details: ::core::option::Option<super::super::common::v1::Payloads>,
    #[prost(string, tag = "3")]
    pub identity: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub namespace: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RespondActivityTaskCanceledResponse {}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RespondActivityTaskCanceledByIdRequest {
    #[prost(string, tag = "1")]
    pub namespace: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub workflow_id: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub run_id: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub activity_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "5")]
    pub details: ::core::option::Option<super::super::common::v1::Payloads>,
    #[prost(string, tag = "6")]
    pub identity: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RespondActivityTaskCanceledByIdResponse {}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RequestCancelWorkflowExecutionRequest {
    #[prost(string, tag = "1")]
    pub namespace: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub workflow_execution: ::core::option::Option<super::super::common::v1::WorkflowExecution>,
    #[prost(string, tag = "3")]
    pub identity: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub request_id: ::prost::alloc::string::String,
    #[prost(string, tag = "5")]
    pub first_execution_run_id: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RequestCancelWorkflowExecutionResponse {}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SignalWorkflowExecutionRequest {
    #[prost(string, tag = "1")]
    pub namespace: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub workflow_execution: ::core::option::Option<super::super::common::v1::WorkflowExecution>,
    #[prost(string, tag = "3")]
    pub signal_name: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "4")]
    pub input: ::core::option::Option<super::super::common::v1::Payloads>,
    #[prost(string, tag = "5")]
    pub identity: ::prost::alloc::string::String,
    #[prost(string, tag = "6")]
    pub request_id: ::prost::alloc::string::String,
    #[prost(string, tag = "7")]
    pub control: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SignalWorkflowExecutionResponse {}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SignalWithStartWorkflowExecutionRequest {
    #[prost(string, tag = "1")]
    pub namespace: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub workflow_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub workflow_type: ::core::option::Option<super::super::common::v1::WorkflowType>,
    #[prost(message, optional, tag = "4")]
    pub task_queue: ::core::option::Option<super::super::taskqueue::v1::TaskQueue>,
    #[prost(message, optional, tag = "5")]
    pub input: ::core::option::Option<super::super::common::v1::Payloads>,
    /// Total workflow execution timeout including retries and continue as new
    #[prost(message, optional, tag = "6")]
    pub workflow_execution_timeout: ::core::option::Option<::prost_types::Duration>,
    /// Timeout of a single workflow run
    #[prost(message, optional, tag = "7")]
    pub workflow_run_timeout: ::core::option::Option<::prost_types::Duration>,
    /// Timeout of a single workflow task
    #[prost(message, optional, tag = "8")]
    pub workflow_task_timeout: ::core::option::Option<::prost_types::Duration>,
    #[prost(string, tag = "9")]
    pub identity: ::prost::alloc::string::String,
    #[prost(string, tag = "10")]
    pub request_id: ::prost::alloc::string::String,
    #[prost(
        enumeration = "super::super::enums::v1::WorkflowIdReusePolicy",
        tag = "11"
    )]
    pub workflow_id_reuse_policy: i32,
    #[prost(string, tag = "12")]
    pub signal_name: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "13")]
    pub signal_input: ::core::option::Option<super::super::common::v1::Payloads>,
    #[prost(string, tag = "14")]
    pub control: ::prost::alloc::string::String,
    /// Default: WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE.
    #[prost(message, optional, tag = "15")]
    pub retry_policy: ::core::option::Option<super::super::common::v1::RetryPolicy>,
    #[prost(string, tag = "16")]
    pub cron_schedule: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "17")]
    pub memo: ::core::option::Option<super::super::common::v1::Memo>,
    #[prost(message, optional, tag = "18")]
    pub search_attributes: ::core::option::Option<super::super::common::v1::SearchAttributes>,
    #[prost(message, optional, tag = "19")]
    pub header: ::core::option::Option<super::super::common::v1::Header>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SignalWithStartWorkflowExecutionResponse {
    #[prost(string, tag = "1")]
    pub run_id: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResetWorkflowExecutionRequest {
    #[prost(string, tag = "1")]
    pub namespace: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub workflow_execution: ::core::option::Option<super::super::common::v1::WorkflowExecution>,
    #[prost(string, tag = "3")]
    pub reason: ::prost::alloc::string::String,
    #[prost(int64, tag = "4")]
    pub workflow_task_finish_event_id: i64,
    #[prost(string, tag = "5")]
    pub request_id: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResetWorkflowExecutionResponse {
    #[prost(string, tag = "1")]
    pub run_id: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TerminateWorkflowExecutionRequest {
    #[prost(string, tag = "1")]
    pub namespace: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub workflow_execution: ::core::option::Option<super::super::common::v1::WorkflowExecution>,
    #[prost(string, tag = "3")]
    pub reason: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "4")]
    pub details: ::core::option::Option<super::super::common::v1::Payloads>,
    #[prost(string, tag = "5")]
    pub identity: ::prost::alloc::string::String,
    #[prost(string, tag = "6")]
    pub first_execution_run_id: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TerminateWorkflowExecutionResponse {}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListOpenWorkflowExecutionsRequest {
    #[prost(string, tag = "1")]
    pub namespace: ::prost::alloc::string::String,
    #[prost(int32, tag = "2")]
    pub maximum_page_size: i32,
    #[prost(bytes = "vec", tag = "3")]
    pub next_page_token: ::prost::alloc::vec::Vec<u8>,
    #[prost(message, optional, tag = "4")]
    pub start_time_filter: ::core::option::Option<super::super::filter::v1::StartTimeFilter>,
    #[prost(
        oneof = "list_open_workflow_executions_request::Filters",
        tags = "5, 6"
    )]
    pub filters: ::core::option::Option<list_open_workflow_executions_request::Filters>,
}
/// Nested message and enum types in `ListOpenWorkflowExecutionsRequest`.
pub mod list_open_workflow_executions_request {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Filters {
        #[prost(message, tag = "5")]
        ExecutionFilter(super::super::super::filter::v1::WorkflowExecutionFilter),
        #[prost(message, tag = "6")]
        TypeFilter(super::super::super::filter::v1::WorkflowTypeFilter),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListOpenWorkflowExecutionsResponse {
    #[prost(message, repeated, tag = "1")]
    pub executions: ::prost::alloc::vec::Vec<super::super::workflow::v1::WorkflowExecutionInfo>,
    #[prost(bytes = "vec", tag = "2")]
    pub next_page_token: ::prost::alloc::vec::Vec<u8>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListClosedWorkflowExecutionsRequest {
    #[prost(string, tag = "1")]
    pub namespace: ::prost::alloc::string::String,
    #[prost(int32, tag = "2")]
    pub maximum_page_size: i32,
    #[prost(bytes = "vec", tag = "3")]
    pub next_page_token: ::prost::alloc::vec::Vec<u8>,
    #[prost(message, optional, tag = "4")]
    pub start_time_filter: ::core::option::Option<super::super::filter::v1::StartTimeFilter>,
    #[prost(
        oneof = "list_closed_workflow_executions_request::Filters",
        tags = "5, 6, 7"
    )]
    pub filters: ::core::option::Option<list_closed_workflow_executions_request::Filters>,
}
/// Nested message and enum types in `ListClosedWorkflowExecutionsRequest`.
pub mod list_closed_workflow_executions_request {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Filters {
        #[prost(message, tag = "5")]
        ExecutionFilter(super::super::super::filter::v1::WorkflowExecutionFilter),
        #[prost(message, tag = "6")]
        TypeFilter(super::super::super::filter::v1::WorkflowTypeFilter),
        #[prost(message, tag = "7")]
        StatusFilter(super::super::super::filter::v1::StatusFilter),
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListClosedWorkflowExecutionsResponse {
    #[prost(message, repeated, tag = "1")]
    pub executions: ::prost::alloc::vec::Vec<super::super::workflow::v1::WorkflowExecutionInfo>,
    #[prost(bytes = "vec", tag = "2")]
    pub next_page_token: ::prost::alloc::vec::Vec<u8>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListWorkflowExecutionsRequest {
    #[prost(string, tag = "1")]
    pub namespace: ::prost::alloc::string::String,
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    #[prost(bytes = "vec", tag = "3")]
    pub next_page_token: ::prost::alloc::vec::Vec<u8>,
    #[prost(string, tag = "4")]
    pub query: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListWorkflowExecutionsResponse {
    #[prost(message, repeated, tag = "1")]
    pub executions: ::prost::alloc::vec::Vec<super::super::workflow::v1::WorkflowExecutionInfo>,
    #[prost(bytes = "vec", tag = "2")]
    pub next_page_token: ::prost::alloc::vec::Vec<u8>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListArchivedWorkflowExecutionsRequest {
    #[prost(string, tag = "1")]
    pub namespace: ::prost::alloc::string::String,
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    #[prost(bytes = "vec", tag = "3")]
    pub next_page_token: ::prost::alloc::vec::Vec<u8>,
    #[prost(string, tag = "4")]
    pub query: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListArchivedWorkflowExecutionsResponse {
    #[prost(message, repeated, tag = "1")]
    pub executions: ::prost::alloc::vec::Vec<super::super::workflow::v1::WorkflowExecutionInfo>,
    #[prost(bytes = "vec", tag = "2")]
    pub next_page_token: ::prost::alloc::vec::Vec<u8>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ScanWorkflowExecutionsRequest {
    #[prost(string, tag = "1")]
    pub namespace: ::prost::alloc::string::String,
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    #[prost(bytes = "vec", tag = "3")]
    pub next_page_token: ::prost::alloc::vec::Vec<u8>,
    #[prost(string, tag = "4")]
    pub query: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ScanWorkflowExecutionsResponse {
    #[prost(message, repeated, tag = "1")]
    pub executions: ::prost::alloc::vec::Vec<super::super::workflow::v1::WorkflowExecutionInfo>,
    #[prost(bytes = "vec", tag = "2")]
    pub next_page_token: ::prost::alloc::vec::Vec<u8>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CountWorkflowExecutionsRequest {
    #[prost(string, tag = "1")]
    pub namespace: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub query: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CountWorkflowExecutionsResponse {
    #[prost(int64, tag = "1")]
    pub count: i64,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetSearchAttributesRequest {}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetSearchAttributesResponse {
    #[prost(
        map = "string, enumeration(super::super::enums::v1::IndexedValueType)",
        tag = "1"
    )]
    pub keys: ::std::collections::HashMap<::prost::alloc::string::String, i32>,
}
/// TODO:  deprecated APIs
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RespondQueryTaskCompletedRequest {
    #[prost(bytes = "vec", tag = "1")]
    pub task_token: ::prost::alloc::vec::Vec<u8>,
    #[prost(enumeration = "super::super::enums::v1::QueryResultType", tag = "2")]
    pub completed_type: i32,
    #[prost(message, optional, tag = "3")]
    pub query_result: ::core::option::Option<super::super::common::v1::Payloads>,
    #[prost(string, tag = "4")]
    pub error_message: ::prost::alloc::string::String,
    #[prost(string, tag = "6")]
    pub namespace: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RespondQueryTaskCompletedResponse {}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResetStickyTaskQueueRequest {
    #[prost(string, tag = "1")]
    pub namespace: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub execution: ::core::option::Option<super::super::common::v1::WorkflowExecution>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResetStickyTaskQueueResponse {}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryWorkflowRequest {
    #[prost(string, tag = "1")]
    pub namespace: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub execution: ::core::option::Option<super::super::common::v1::WorkflowExecution>,
    #[prost(message, optional, tag = "3")]
    pub query: ::core::option::Option<super::super::query::v1::WorkflowQuery>,
    /// QueryRejectCondition can used to reject the query if workflow state does not satisfy condition.
    /// Default: QUERY_REJECT_CONDITION_NONE.
    #[prost(
        enumeration = "super::super::enums::v1::QueryRejectCondition",
        tag = "4"
    )]
    pub query_reject_condition: i32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryWorkflowResponse {
    #[prost(message, optional, tag = "1")]
    pub query_result: ::core::option::Option<super::super::common::v1::Payloads>,
    #[prost(message, optional, tag = "2")]
    pub query_rejected: ::core::option::Option<super::super::query::v1::QueryRejected>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DescribeWorkflowExecutionRequest {
    #[prost(string, tag = "1")]
    pub namespace: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub execution: ::core::option::Option<super::super::common::v1::WorkflowExecution>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DescribeWorkflowExecutionResponse {
    #[prost(message, optional, tag = "1")]
    pub execution_config:
        ::core::option::Option<super::super::workflow::v1::WorkflowExecutionConfig>,
    #[prost(message, optional, tag = "2")]
    pub workflow_execution_info:
        ::core::option::Option<super::super::workflow::v1::WorkflowExecutionInfo>,
    #[prost(message, repeated, tag = "3")]
    pub pending_activities:
        ::prost::alloc::vec::Vec<super::super::workflow::v1::PendingActivityInfo>,
    #[prost(message, repeated, tag = "4")]
    pub pending_children:
        ::prost::alloc::vec::Vec<super::super::workflow::v1::PendingChildExecutionInfo>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DescribeTaskQueueRequest {
    #[prost(string, tag = "1")]
    pub namespace: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub task_queue: ::core::option::Option<super::super::taskqueue::v1::TaskQueue>,
    #[prost(enumeration = "super::super::enums::v1::TaskQueueType", tag = "3")]
    pub task_queue_type: i32,
    #[prost(bool, tag = "4")]
    pub include_task_queue_status: bool,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DescribeTaskQueueResponse {
    #[prost(message, repeated, tag = "1")]
    pub pollers: ::prost::alloc::vec::Vec<super::super::taskqueue::v1::PollerInfo>,
    #[prost(message, optional, tag = "2")]
    pub task_queue_status: ::core::option::Option<super::super::taskqueue::v1::TaskQueueStatus>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetClusterInfoRequest {}
/// GetClusterInfoResponse contains information about Temporal cluster.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetClusterInfoResponse {
    /// Key is client name i.e "temporal-go", "temporal-java", or "temporal-cli".
    /// Value is ranges of supported versions of this client i.e ">1.1.1 <=1.4.0 || ^5.0.0".
    #[prost(map = "string, string", tag = "1")]
    pub supported_clients:
        ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    #[prost(string, tag = "2")]
    pub server_version: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub cluster_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "4")]
    pub version_info: ::core::option::Option<super::super::version::v1::VersionInfo>,
    #[prost(string, tag = "5")]
    pub cluster_name: ::prost::alloc::string::String,
    #[prost(int32, tag = "6")]
    pub history_shard_count: i32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListTaskQueuePartitionsRequest {
    #[prost(string, tag = "1")]
    pub namespace: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub task_queue: ::core::option::Option<super::super::taskqueue::v1::TaskQueue>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListTaskQueuePartitionsResponse {
    #[prost(message, repeated, tag = "1")]
    pub activity_task_queue_partitions:
        ::prost::alloc::vec::Vec<super::super::taskqueue::v1::TaskQueuePartitionMetadata>,
    #[prost(message, repeated, tag = "2")]
    pub workflow_task_queue_partitions:
        ::prost::alloc::vec::Vec<super::super::taskqueue::v1::TaskQueuePartitionMetadata>,
}
#[doc = r" Generated client implementations."]
pub mod workflow_service_client {
    #![allow(unused_variables, dead_code, missing_docs)]
    use tonic::codegen::*;
    #[doc = " WorkflowService API is exposed to provide support for long running applications.  Application is expected to call"]
    #[doc = " StartWorkflowExecution to create an instance for each instance of long running workflow.  Such applications are expected"]
    #[doc = " to have a worker which regularly polls for WorkflowTask and ActivityTask from the WorkflowService.  For each"]
    #[doc = " WorkflowTask, application is expected to process the history of events for that session and respond back with next"]
    #[doc = " commands.  For each ActivityTask, application is expected to execute the actual logic for that task and respond back"]
    #[doc = " with completion or failure.  Worker is expected to regularly heartbeat while activity task is running."]
    pub struct WorkflowServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl WorkflowServiceClient<tonic::transport::Channel> {
        #[doc = r" Attempt to create a new client by connecting to a given endpoint."]
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: std::convert::TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> WorkflowServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::ResponseBody: Body + HttpBody + Send + 'static,
        T::Error: Into<StdError>,
        <T::ResponseBody as HttpBody>::Error: Into<StdError> + Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_interceptor(inner: T, interceptor: impl Into<tonic::Interceptor>) -> Self {
            let inner = tonic::client::Grpc::with_interceptor(inner, interceptor);
            Self { inner }
        }
        #[doc = " RegisterNamespace creates a new namespace which can be used as a container for all resources.  Namespace is a top level"]
        #[doc = " entity within Temporal, used as a container for all resources like workflow executions, task queues, etc.  Namespace"]
        #[doc = " acts as a sandbox and provides isolation for all resources within the namespace.  All resources belongs to exactly one"]
        #[doc = " namespace."]
        pub async fn register_namespace(
            &mut self,
            request: impl tonic::IntoRequest<super::RegisterNamespaceRequest>,
        ) -> Result<tonic::Response<super::RegisterNamespaceResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/RegisterNamespace",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " DescribeNamespace returns the information and configuration for a registered namespace."]
        pub async fn describe_namespace(
            &mut self,
            request: impl tonic::IntoRequest<super::DescribeNamespaceRequest>,
        ) -> Result<tonic::Response<super::DescribeNamespaceResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/DescribeNamespace",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " ListNamespaces returns the information and configuration for all namespaces."]
        pub async fn list_namespaces(
            &mut self,
            request: impl tonic::IntoRequest<super::ListNamespacesRequest>,
        ) -> Result<tonic::Response<super::ListNamespacesResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/ListNamespaces",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " (-- api-linter: core::0134::method-signature=disabled"]
        #[doc = "     aip.dev/not-precedent: UpdateNamespace RPC doesn't follow Google API format. --)"]
        #[doc = " (-- api-linter: core::0134::response-message-name=disabled"]
        #[doc = "     aip.dev/not-precedent: UpdateNamespace RPC doesn't follow Google API format. --)"]
        #[doc = " UpdateNamespace is used to update the information and configuration for a registered namespace."]
        pub async fn update_namespace(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateNamespaceRequest>,
        ) -> Result<tonic::Response<super::UpdateNamespaceResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/UpdateNamespace",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " DeprecateNamespace is used to update state of a registered namespace to DEPRECATED.  Once the namespace is deprecated"]
        #[doc = " it cannot be used to start new workflow executions.  Existing workflow executions will continue to run on"]
        #[doc = " deprecated namespaces."]
        pub async fn deprecate_namespace(
            &mut self,
            request: impl tonic::IntoRequest<super::DeprecateNamespaceRequest>,
        ) -> Result<tonic::Response<super::DeprecateNamespaceResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/DeprecateNamespace",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " StartWorkflowExecution starts a new long running workflow instance.  It will create the instance with"]
        #[doc = " 'WorkflowExecutionStarted' event in history and also schedule the first WorkflowTask for the worker to make the"]
        #[doc = " first command for this instance.  It will return 'WorkflowExecutionAlreadyStartedFailure', if an instance already"]
        #[doc = " exists with same workflowId."]
        pub async fn start_workflow_execution(
            &mut self,
            request: impl tonic::IntoRequest<super::StartWorkflowExecutionRequest>,
        ) -> Result<tonic::Response<super::StartWorkflowExecutionResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/StartWorkflowExecution",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " GetWorkflowExecutionHistory returns the history of specified workflow execution.  It fails with 'NotFoundFailure' if specified workflow"]
        #[doc = " execution in unknown to the service."]
        pub async fn get_workflow_execution_history(
            &mut self,
            request: impl tonic::IntoRequest<super::GetWorkflowExecutionHistoryRequest>,
        ) -> Result<tonic::Response<super::GetWorkflowExecutionHistoryResponse>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/GetWorkflowExecutionHistory",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " PollWorkflowTaskQueue is called by application worker to process WorkflowTask from a specific task queue.  A"]
        #[doc = " WorkflowTask is dispatched to callers for active workflow executions, with pending workflow tasks."]
        #[doc = " Application is then expected to call 'RespondWorkflowTaskCompleted' API when it is done processing the WorkflowTask."]
        #[doc = " It will also create a 'WorkflowTaskStarted' event in the history for that session before handing off WorkflowTask to"]
        #[doc = " application worker."]
        pub async fn poll_workflow_task_queue(
            &mut self,
            request: impl tonic::IntoRequest<super::PollWorkflowTaskQueueRequest>,
        ) -> Result<tonic::Response<super::PollWorkflowTaskQueueResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/PollWorkflowTaskQueue",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " RespondWorkflowTaskCompleted is called by application worker to complete a WorkflowTask handed as a result of"]
        #[doc = " 'PollWorkflowTaskQueue' API call.  Completing a WorkflowTask will result in new events for the workflow execution and"]
        #[doc = " potentially new ActivityTask being created for corresponding commands.  It will also create a WorkflowTaskCompleted"]
        #[doc = " event in the history for that session.  Use the 'taskToken' provided as response of PollWorkflowTaskQueue API call"]
        #[doc = " for completing the WorkflowTask."]
        #[doc = " The response could contain a new workflow task if there is one or if the request asking for one."]
        pub async fn respond_workflow_task_completed(
            &mut self,
            request: impl tonic::IntoRequest<super::RespondWorkflowTaskCompletedRequest>,
        ) -> Result<tonic::Response<super::RespondWorkflowTaskCompletedResponse>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/RespondWorkflowTaskCompleted",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " RespondWorkflowTaskFailed is called by application worker to indicate failure.  This results in"]
        #[doc = " WorkflowTaskFailedEvent written to the history and a new WorkflowTask created.  This API can be used by client to"]
        #[doc = " either clear sticky task queue or report any panics during WorkflowTask processing.  Temporal will only append first"]
        #[doc = " WorkflowTaskFailed event to the history of workflow execution for consecutive failures."]
        pub async fn respond_workflow_task_failed(
            &mut self,
            request: impl tonic::IntoRequest<super::RespondWorkflowTaskFailedRequest>,
        ) -> Result<tonic::Response<super::RespondWorkflowTaskFailedResponse>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/RespondWorkflowTaskFailed",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " PollActivityTaskQueue is called by application worker to process ActivityTask from a specific task queue.  ActivityTask"]
        #[doc = " is dispatched to callers whenever a ScheduleTask command is made for a workflow execution."]
        #[doc = " Application is expected to call 'RespondActivityTaskCompleted' or 'RespondActivityTaskFailed' once it is done"]
        #[doc = " processing the task."]
        #[doc = " Application also needs to call 'RecordActivityTaskHeartbeat' API within 'heartbeatTimeoutSeconds' interval to"]
        #[doc = " prevent the task from getting timed out.  An event 'ActivityTaskStarted' event is also written to workflow execution"]
        #[doc = " history before the ActivityTask is dispatched to application worker."]
        pub async fn poll_activity_task_queue(
            &mut self,
            request: impl tonic::IntoRequest<super::PollActivityTaskQueueRequest>,
        ) -> Result<tonic::Response<super::PollActivityTaskQueueResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/PollActivityTaskQueue",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " RecordActivityTaskHeartbeat is called by application worker while it is processing an ActivityTask.  If worker fails"]
        #[doc = " to heartbeat within 'heartbeatTimeoutSeconds' interval for the ActivityTask, then it will be marked as timedout and"]
        #[doc = " 'ActivityTaskTimedOut' event will be written to the workflow history.  Calling 'RecordActivityTaskHeartbeat' will"]
        #[doc = " fail with 'NotFoundFailure' in such situations.  Use the 'taskToken' provided as response of"]
        #[doc = " PollActivityTaskQueue API call for heart beating."]
        pub async fn record_activity_task_heartbeat(
            &mut self,
            request: impl tonic::IntoRequest<super::RecordActivityTaskHeartbeatRequest>,
        ) -> Result<tonic::Response<super::RecordActivityTaskHeartbeatResponse>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/RecordActivityTaskHeartbeat",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " (-- api-linter: core::0136::prepositions=disabled"]
        #[doc = "     aip.dev/not-precedent: \"By\" is used to indicate request type. --)"]
        #[doc = " RecordActivityTaskHeartbeatById is called by application worker while it is processing an ActivityTask.  If worker fails"]
        #[doc = " to heartbeat within 'heartbeatTimeoutSeconds' interval for the ActivityTask, then it will be marked as timed out and"]
        #[doc = " 'ActivityTaskTimedOut' event will be written to the workflow history.  Calling 'RecordActivityTaskHeartbeatById' will"]
        #[doc = " fail with 'NotFoundFailure' in such situations.  Instead of using 'taskToken' like in RecordActivityTaskHeartbeat,"]
        #[doc = " use Namespace, WorkflowId and ActivityId"]
        pub async fn record_activity_task_heartbeat_by_id(
            &mut self,
            request: impl tonic::IntoRequest<super::RecordActivityTaskHeartbeatByIdRequest>,
        ) -> Result<tonic::Response<super::RecordActivityTaskHeartbeatByIdResponse>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/RecordActivityTaskHeartbeatById",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " RespondActivityTaskCompleted is called by application worker when it is done processing an ActivityTask.  It will"]
        #[doc = " result in a new 'ActivityTaskCompleted' event being written to the workflow history and a new WorkflowTask"]
        #[doc = " created for the workflow so new commands could be made.  Use the 'taskToken' provided as response of"]
        #[doc = " PollActivityTaskQueue API call for completion. It fails with 'NotFoundFailure' if the taskToken is not valid"]
        #[doc = " anymore due to activity timeout."]
        pub async fn respond_activity_task_completed(
            &mut self,
            request: impl tonic::IntoRequest<super::RespondActivityTaskCompletedRequest>,
        ) -> Result<tonic::Response<super::RespondActivityTaskCompletedResponse>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/RespondActivityTaskCompleted",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " (-- api-linter: core::0136::prepositions=disabled"]
        #[doc = "     aip.dev/not-precedent: \"By\" is used to indicate request type. --)"]
        #[doc = " RespondActivityTaskCompletedById is called by application worker when it is done processing an ActivityTask."]
        #[doc = " It will result in a new 'ActivityTaskCompleted' event being written to the workflow history and a new WorkflowTask"]
        #[doc = " created for the workflow so new commands could be made.  Similar to RespondActivityTaskCompleted but use Namespace,"]
        #[doc = " WorkflowId and ActivityId instead of 'taskToken' for completion. It fails with 'NotFoundFailure'"]
        #[doc = " if the these Ids are not valid anymore due to activity timeout."]
        pub async fn respond_activity_task_completed_by_id(
            &mut self,
            request: impl tonic::IntoRequest<super::RespondActivityTaskCompletedByIdRequest>,
        ) -> Result<tonic::Response<super::RespondActivityTaskCompletedByIdResponse>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/RespondActivityTaskCompletedById",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " RespondActivityTaskFailed is called by application worker when it is done processing an ActivityTask.  It will"]
        #[doc = " result in a new 'ActivityTaskFailed' event being written to the workflow history and a new WorkflowTask"]
        #[doc = " created for the workflow instance so new commands could be made.  Use the 'taskToken' provided as response of"]
        #[doc = " PollActivityTaskQueue API call for completion. It fails with 'NotFoundFailure' if the taskToken is not valid"]
        #[doc = " anymore due to activity timeout."]
        pub async fn respond_activity_task_failed(
            &mut self,
            request: impl tonic::IntoRequest<super::RespondActivityTaskFailedRequest>,
        ) -> Result<tonic::Response<super::RespondActivityTaskFailedResponse>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/RespondActivityTaskFailed",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " (-- api-linter: core::0136::prepositions=disabled"]
        #[doc = "     aip.dev/not-precedent: \"By\" is used to indicate request type. --)"]
        #[doc = " RespondActivityTaskFailedById is called by application worker when it is done processing an ActivityTask."]
        #[doc = " It will result in a new 'ActivityTaskFailed' event being written to the workflow history and a new WorkflowTask"]
        #[doc = " created for the workflow instance so new commands could be made.  Similar to RespondActivityTaskFailed but use"]
        #[doc = " Namespace, WorkflowId and ActivityId instead of 'taskToken' for completion. It fails with 'NotFoundFailure'"]
        #[doc = " if the these Ids are not valid anymore due to activity timeout."]
        pub async fn respond_activity_task_failed_by_id(
            &mut self,
            request: impl tonic::IntoRequest<super::RespondActivityTaskFailedByIdRequest>,
        ) -> Result<tonic::Response<super::RespondActivityTaskFailedByIdResponse>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/RespondActivityTaskFailedById",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " RespondActivityTaskCanceled is called by application worker when it is successfully canceled an ActivityTask.  It will"]
        #[doc = " result in a new 'ActivityTaskCanceled' event being written to the workflow history and a new WorkflowTask"]
        #[doc = " created for the workflow instance so new commands could be made.  Use the 'taskToken' provided as response of"]
        #[doc = " PollActivityTaskQueue API call for completion. It fails with 'NotFoundFailure' if the taskToken is not valid"]
        #[doc = " anymore due to activity timeout."]
        pub async fn respond_activity_task_canceled(
            &mut self,
            request: impl tonic::IntoRequest<super::RespondActivityTaskCanceledRequest>,
        ) -> Result<tonic::Response<super::RespondActivityTaskCanceledResponse>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/RespondActivityTaskCanceled",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " (-- api-linter: core::0136::prepositions=disabled"]
        #[doc = "     aip.dev/not-precedent: \"By\" is used to indicate request type. --)"]
        #[doc = " RespondActivityTaskCanceledById is called by application worker when it is successfully canceled an ActivityTask."]
        #[doc = " It will result in a new 'ActivityTaskCanceled' event being written to the workflow history and a new WorkflowTask"]
        #[doc = " created for the workflow instance so new commands could be made.  Similar to RespondActivityTaskCanceled but use"]
        #[doc = " Namespace, WorkflowId and ActivityId instead of 'taskToken' for completion. It fails with 'NotFoundFailure'"]
        #[doc = " if the these Ids are not valid anymore due to activity timeout."]
        pub async fn respond_activity_task_canceled_by_id(
            &mut self,
            request: impl tonic::IntoRequest<super::RespondActivityTaskCanceledByIdRequest>,
        ) -> Result<tonic::Response<super::RespondActivityTaskCanceledByIdResponse>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/RespondActivityTaskCanceledById",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " RequestCancelWorkflowExecution is called by application worker when it wants to request cancellation of a workflow instance."]
        #[doc = " It will result in a new 'WorkflowExecutionCancelRequested' event being written to the workflow history and a new WorkflowTask"]
        #[doc = " created for the workflow instance so new commands could be made. It fails with 'NotFoundFailure' if the workflow is not valid"]
        #[doc = " anymore due to completion or doesn't exist."]
        pub async fn request_cancel_workflow_execution(
            &mut self,
            request: impl tonic::IntoRequest<super::RequestCancelWorkflowExecutionRequest>,
        ) -> Result<tonic::Response<super::RequestCancelWorkflowExecutionResponse>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/RequestCancelWorkflowExecution",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " SignalWorkflowExecution is used to send a signal event to running workflow execution.  This results in"]
        #[doc = " WorkflowExecutionSignaled event recorded in the history and a workflow task being created for the execution."]
        pub async fn signal_workflow_execution(
            &mut self,
            request: impl tonic::IntoRequest<super::SignalWorkflowExecutionRequest>,
        ) -> Result<tonic::Response<super::SignalWorkflowExecutionResponse>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/SignalWorkflowExecution",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " (-- api-linter: core::0136::prepositions=disabled"]
        #[doc = "     aip.dev/not-precedent: \"With\" is used to indicate combined operation. --)"]
        #[doc = " SignalWithStartWorkflowExecution is used to ensure sending signal to a workflow."]
        #[doc = " If the workflow is running, this results in WorkflowExecutionSignaled event being recorded in the history"]
        #[doc = " and a workflow task being created for the execution."]
        #[doc = " If the workflow is not running or not found, this results in WorkflowExecutionStarted and WorkflowExecutionSignaled"]
        #[doc = " events being recorded in history, and a workflow task being created for the execution"]
        pub async fn signal_with_start_workflow_execution(
            &mut self,
            request: impl tonic::IntoRequest<super::SignalWithStartWorkflowExecutionRequest>,
        ) -> Result<tonic::Response<super::SignalWithStartWorkflowExecutionResponse>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/SignalWithStartWorkflowExecution",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " ResetWorkflowExecution reset an existing workflow execution to WorkflowTaskCompleted event(exclusive)."]
        #[doc = " And it will immediately terminating the current execution instance."]
        pub async fn reset_workflow_execution(
            &mut self,
            request: impl tonic::IntoRequest<super::ResetWorkflowExecutionRequest>,
        ) -> Result<tonic::Response<super::ResetWorkflowExecutionResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/ResetWorkflowExecution",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " TerminateWorkflowExecution terminates an existing workflow execution by recording WorkflowExecutionTerminated event"]
        #[doc = " in the history and immediately terminating the execution instance."]
        pub async fn terminate_workflow_execution(
            &mut self,
            request: impl tonic::IntoRequest<super::TerminateWorkflowExecutionRequest>,
        ) -> Result<tonic::Response<super::TerminateWorkflowExecutionResponse>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/TerminateWorkflowExecution",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " ListOpenWorkflowExecutions is a visibility API to list the open executions in a specific namespace."]
        pub async fn list_open_workflow_executions(
            &mut self,
            request: impl tonic::IntoRequest<super::ListOpenWorkflowExecutionsRequest>,
        ) -> Result<tonic::Response<super::ListOpenWorkflowExecutionsResponse>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/ListOpenWorkflowExecutions",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " ListClosedWorkflowExecutions is a visibility API to list the closed executions in a specific namespace."]
        pub async fn list_closed_workflow_executions(
            &mut self,
            request: impl tonic::IntoRequest<super::ListClosedWorkflowExecutionsRequest>,
        ) -> Result<tonic::Response<super::ListClosedWorkflowExecutionsResponse>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/ListClosedWorkflowExecutions",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " ListWorkflowExecutions is a visibility API to list workflow executions in a specific namespace."]
        pub async fn list_workflow_executions(
            &mut self,
            request: impl tonic::IntoRequest<super::ListWorkflowExecutionsRequest>,
        ) -> Result<tonic::Response<super::ListWorkflowExecutionsResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/ListWorkflowExecutions",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " ListArchivedWorkflowExecutions is a visibility API to list archived workflow executions in a specific namespace."]
        pub async fn list_archived_workflow_executions(
            &mut self,
            request: impl tonic::IntoRequest<super::ListArchivedWorkflowExecutionsRequest>,
        ) -> Result<tonic::Response<super::ListArchivedWorkflowExecutionsResponse>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/ListArchivedWorkflowExecutions",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " ScanWorkflowExecutions is a visibility API to list large amount of workflow executions in a specific namespace without order."]
        pub async fn scan_workflow_executions(
            &mut self,
            request: impl tonic::IntoRequest<super::ScanWorkflowExecutionsRequest>,
        ) -> Result<tonic::Response<super::ScanWorkflowExecutionsResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/ScanWorkflowExecutions",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " CountWorkflowExecutions is a visibility API to count of workflow executions in a specific namespace."]
        pub async fn count_workflow_executions(
            &mut self,
            request: impl tonic::IntoRequest<super::CountWorkflowExecutionsRequest>,
        ) -> Result<tonic::Response<super::CountWorkflowExecutionsResponse>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/CountWorkflowExecutions",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " GetSearchAttributes is a visibility API to get all legal keys that could be used in list APIs"]
        pub async fn get_search_attributes(
            &mut self,
            request: impl tonic::IntoRequest<super::GetSearchAttributesRequest>,
        ) -> Result<tonic::Response<super::GetSearchAttributesResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/GetSearchAttributes",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " RespondQueryTaskCompleted is called by application worker to complete a QueryTask (which is a WorkflowTask for query)"]
        #[doc = " as a result of 'PollWorkflowTaskQueue' API call. Completing a QueryTask will unblock the client call to 'QueryWorkflow'"]
        #[doc = " API and return the query result to client as a response to 'QueryWorkflow' API call."]
        pub async fn respond_query_task_completed(
            &mut self,
            request: impl tonic::IntoRequest<super::RespondQueryTaskCompletedRequest>,
        ) -> Result<tonic::Response<super::RespondQueryTaskCompletedResponse>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/RespondQueryTaskCompleted",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " ResetStickyTaskQueue resets the sticky task queue related information in mutable state of a given workflow."]
        #[doc = " Things cleared are:"]
        #[doc = " 1. StickyTaskQueue"]
        #[doc = " 2. StickyScheduleToStartTimeout"]
        pub async fn reset_sticky_task_queue(
            &mut self,
            request: impl tonic::IntoRequest<super::ResetStickyTaskQueueRequest>,
        ) -> Result<tonic::Response<super::ResetStickyTaskQueueResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/ResetStickyTaskQueue",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " QueryWorkflow returns query result for a specified workflow execution"]
        pub async fn query_workflow(
            &mut self,
            request: impl tonic::IntoRequest<super::QueryWorkflowRequest>,
        ) -> Result<tonic::Response<super::QueryWorkflowResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/QueryWorkflow",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " DescribeWorkflowExecution returns information about the specified workflow execution."]
        pub async fn describe_workflow_execution(
            &mut self,
            request: impl tonic::IntoRequest<super::DescribeWorkflowExecutionRequest>,
        ) -> Result<tonic::Response<super::DescribeWorkflowExecutionResponse>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/DescribeWorkflowExecution",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " DescribeTaskQueue returns information about the target task queue, right now this API returns the"]
        #[doc = " pollers which polled this task queue in last few minutes."]
        pub async fn describe_task_queue(
            &mut self,
            request: impl tonic::IntoRequest<super::DescribeTaskQueueRequest>,
        ) -> Result<tonic::Response<super::DescribeTaskQueueResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/DescribeTaskQueue",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " GetClusterInfo returns information about temporal cluster"]
        pub async fn get_cluster_info(
            &mut self,
            request: impl tonic::IntoRequest<super::GetClusterInfoRequest>,
        ) -> Result<tonic::Response<super::GetClusterInfoResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/GetClusterInfo",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        pub async fn list_task_queue_partitions(
            &mut self,
            request: impl tonic::IntoRequest<super::ListTaskQueuePartitionsRequest>,
        ) -> Result<tonic::Response<super::ListTaskQueuePartitionsResponse>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/temporal.api.workflowservice.v1.WorkflowService/ListTaskQueuePartitions",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
    }
    impl<T: Clone> Clone for WorkflowServiceClient<T> {
        fn clone(&self) -> Self {
            Self {
                inner: self.inner.clone(),
            }
        }
    }
    impl<T> std::fmt::Debug for WorkflowServiceClient<T> {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            write!(f, "WorkflowServiceClient {{ ... }}")
        }
    }
}