durabletask_proto/

microsoft.durabletask.implementation.protobuf.rs

// This file is @generated by prost-build.
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OrchestrationInstance {
    #[prost(string, tag = "1")]
    pub instance_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub execution_id: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for OrchestrationInstance {
    const NAME: &'static str = "OrchestrationInstance";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "OrchestrationInstance".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/OrchestrationInstance".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ActivityRequest {
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub version: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "3")]
    pub input: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "4")]
    pub orchestration_instance: ::core::option::Option<OrchestrationInstance>,
    #[prost(int32, tag = "5")]
    pub task_id: i32,
}
impl ::prost::Name for ActivityRequest {
    const NAME: &'static str = "ActivityRequest";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "ActivityRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ActivityRequest".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ActivityResponse {
    #[prost(string, tag = "1")]
    pub instance_id: ::prost::alloc::string::String,
    #[prost(int32, tag = "2")]
    pub task_id: i32,
    #[prost(message, optional, tag = "3")]
    pub result: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "4")]
    pub failure_details: ::core::option::Option<TaskFailureDetails>,
}
impl ::prost::Name for ActivityResponse {
    const NAME: &'static str = "ActivityResponse";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "ActivityResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ActivityResponse".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TaskFailureDetails {
    #[prost(string, tag = "1")]
    pub error_type: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub error_message: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub stack_trace: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, boxed, tag = "4")]
    pub inner_failure: ::core::option::Option<
        ::prost::alloc::boxed::Box<TaskFailureDetails>,
    >,
    #[prost(bool, tag = "5")]
    pub is_non_retriable: bool,
}
impl ::prost::Name for TaskFailureDetails {
    const NAME: &'static str = "TaskFailureDetails";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "TaskFailureDetails".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/TaskFailureDetails".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ParentInstanceInfo {
    #[prost(int32, tag = "1")]
    pub task_scheduled_id: i32,
    #[prost(message, optional, tag = "2")]
    pub name: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "3")]
    pub version: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "4")]
    pub orchestration_instance: ::core::option::Option<OrchestrationInstance>,
}
impl ::prost::Name for ParentInstanceInfo {
    const NAME: &'static str = "ParentInstanceInfo";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "ParentInstanceInfo".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ParentInstanceInfo".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TraceContext {
    #[prost(string, tag = "1")]
    pub trace_parent: ::prost::alloc::string::String,
    #[deprecated]
    #[prost(string, tag = "2")]
    pub span_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub trace_state: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for TraceContext {
    const NAME: &'static str = "TraceContext";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "TraceContext".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/TraceContext".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExecutionStartedEvent {
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub version: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "3")]
    pub input: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "4")]
    pub orchestration_instance: ::core::option::Option<OrchestrationInstance>,
    #[prost(message, optional, tag = "5")]
    pub parent_instance: ::core::option::Option<ParentInstanceInfo>,
    #[prost(message, optional, tag = "6")]
    pub scheduled_start_timestamp: ::core::option::Option<::prost_wkt_types::Timestamp>,
    #[prost(message, optional, tag = "7")]
    pub parent_trace_context: ::core::option::Option<TraceContext>,
    #[prost(message, optional, tag = "8")]
    pub orchestration_span_id: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for ExecutionStartedEvent {
    const NAME: &'static str = "ExecutionStartedEvent";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "ExecutionStartedEvent".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ExecutionStartedEvent".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExecutionCompletedEvent {
    #[prost(enumeration = "OrchestrationStatus", tag = "1")]
    pub orchestration_status: i32,
    #[prost(message, optional, tag = "2")]
    pub result: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "3")]
    pub failure_details: ::core::option::Option<TaskFailureDetails>,
}
impl ::prost::Name for ExecutionCompletedEvent {
    const NAME: &'static str = "ExecutionCompletedEvent";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "ExecutionCompletedEvent".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ExecutionCompletedEvent".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExecutionTerminatedEvent {
    #[prost(message, optional, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(bool, tag = "2")]
    pub recurse: bool,
}
impl ::prost::Name for ExecutionTerminatedEvent {
    const NAME: &'static str = "ExecutionTerminatedEvent";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "ExecutionTerminatedEvent".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ExecutionTerminatedEvent".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TaskScheduledEvent {
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub version: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "3")]
    pub input: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "4")]
    pub parent_trace_context: ::core::option::Option<TraceContext>,
}
impl ::prost::Name for TaskScheduledEvent {
    const NAME: &'static str = "TaskScheduledEvent";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "TaskScheduledEvent".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/TaskScheduledEvent".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TaskCompletedEvent {
    #[prost(int32, tag = "1")]
    pub task_scheduled_id: i32,
    #[prost(message, optional, tag = "2")]
    pub result: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for TaskCompletedEvent {
    const NAME: &'static str = "TaskCompletedEvent";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "TaskCompletedEvent".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/TaskCompletedEvent".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TaskFailedEvent {
    #[prost(int32, tag = "1")]
    pub task_scheduled_id: i32,
    #[prost(message, optional, tag = "2")]
    pub failure_details: ::core::option::Option<TaskFailureDetails>,
}
impl ::prost::Name for TaskFailedEvent {
    const NAME: &'static str = "TaskFailedEvent";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "TaskFailedEvent".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/TaskFailedEvent".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SubOrchestrationInstanceCreatedEvent {
    #[prost(string, tag = "1")]
    pub instance_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub version: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "4")]
    pub input: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "5")]
    pub parent_trace_context: ::core::option::Option<TraceContext>,
}
impl ::prost::Name for SubOrchestrationInstanceCreatedEvent {
    const NAME: &'static str = "SubOrchestrationInstanceCreatedEvent";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "SubOrchestrationInstanceCreatedEvent".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/SubOrchestrationInstanceCreatedEvent".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SubOrchestrationInstanceCompletedEvent {
    #[prost(int32, tag = "1")]
    pub task_scheduled_id: i32,
    #[prost(message, optional, tag = "2")]
    pub result: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for SubOrchestrationInstanceCompletedEvent {
    const NAME: &'static str = "SubOrchestrationInstanceCompletedEvent";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "SubOrchestrationInstanceCompletedEvent".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/SubOrchestrationInstanceCompletedEvent".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SubOrchestrationInstanceFailedEvent {
    #[prost(int32, tag = "1")]
    pub task_scheduled_id: i32,
    #[prost(message, optional, tag = "2")]
    pub failure_details: ::core::option::Option<TaskFailureDetails>,
}
impl ::prost::Name for SubOrchestrationInstanceFailedEvent {
    const NAME: &'static str = "SubOrchestrationInstanceFailedEvent";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "SubOrchestrationInstanceFailedEvent".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/SubOrchestrationInstanceFailedEvent".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct TimerCreatedEvent {
    #[prost(message, optional, tag = "1")]
    pub fire_at: ::core::option::Option<::prost_wkt_types::Timestamp>,
}
impl ::prost::Name for TimerCreatedEvent {
    const NAME: &'static str = "TimerCreatedEvent";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "TimerCreatedEvent".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/TimerCreatedEvent".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct TimerFiredEvent {
    #[prost(message, optional, tag = "1")]
    pub fire_at: ::core::option::Option<::prost_wkt_types::Timestamp>,
    #[prost(int32, tag = "2")]
    pub timer_id: i32,
}
impl ::prost::Name for TimerFiredEvent {
    const NAME: &'static str = "TimerFiredEvent";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "TimerFiredEvent".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/TimerFiredEvent".into()
    }
}
/// No payload data
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct OrchestratorStartedEvent {}
impl ::prost::Name for OrchestratorStartedEvent {
    const NAME: &'static str = "OrchestratorStartedEvent";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "OrchestratorStartedEvent".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/OrchestratorStartedEvent".into()
    }
}
/// No payload data
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct OrchestratorCompletedEvent {}
impl ::prost::Name for OrchestratorCompletedEvent {
    const NAME: &'static str = "OrchestratorCompletedEvent";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "OrchestratorCompletedEvent".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/OrchestratorCompletedEvent".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EventSentEvent {
    #[prost(string, tag = "1")]
    pub instance_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub input: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for EventSentEvent {
    const NAME: &'static str = "EventSentEvent";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "EventSentEvent".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/EventSentEvent".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EventRaisedEvent {
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub input: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for EventRaisedEvent {
    const NAME: &'static str = "EventRaisedEvent";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "EventRaisedEvent".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/EventRaisedEvent".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GenericEvent {
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for GenericEvent {
    const NAME: &'static str = "GenericEvent";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "GenericEvent".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/GenericEvent".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HistoryStateEvent {
    #[prost(message, optional, tag = "1")]
    pub orchestration_state: ::core::option::Option<OrchestrationState>,
}
impl ::prost::Name for HistoryStateEvent {
    const NAME: &'static str = "HistoryStateEvent";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "HistoryStateEvent".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/HistoryStateEvent".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ContinueAsNewEvent {
    #[prost(message, optional, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for ContinueAsNewEvent {
    const NAME: &'static str = "ContinueAsNewEvent";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "ContinueAsNewEvent".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ContinueAsNewEvent".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExecutionSuspendedEvent {
    #[prost(message, optional, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for ExecutionSuspendedEvent {
    const NAME: &'static str = "ExecutionSuspendedEvent";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "ExecutionSuspendedEvent".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ExecutionSuspendedEvent".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExecutionResumedEvent {
    #[prost(message, optional, tag = "1")]
    pub input: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for ExecutionResumedEvent {
    const NAME: &'static str = "ExecutionResumedEvent";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "ExecutionResumedEvent".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ExecutionResumedEvent".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HistoryEvent {
    #[prost(int32, tag = "1")]
    pub event_id: i32,
    #[prost(message, optional, tag = "2")]
    pub timestamp: ::core::option::Option<::prost_wkt_types::Timestamp>,
    #[prost(
        oneof = "history_event::EventType",
        tags = "3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22"
    )]
    pub event_type: ::core::option::Option<history_event::EventType>,
}
/// Nested message and enum types in `HistoryEvent`.
pub mod history_event {
    #[derive(serde::Serialize, serde::Deserialize)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum EventType {
        #[prost(message, tag = "3")]
        ExecutionStarted(super::ExecutionStartedEvent),
        #[prost(message, tag = "4")]
        ExecutionCompleted(super::ExecutionCompletedEvent),
        #[prost(message, tag = "5")]
        ExecutionTerminated(super::ExecutionTerminatedEvent),
        #[prost(message, tag = "6")]
        TaskScheduled(super::TaskScheduledEvent),
        #[prost(message, tag = "7")]
        TaskCompleted(super::TaskCompletedEvent),
        #[prost(message, tag = "8")]
        TaskFailed(super::TaskFailedEvent),
        #[prost(message, tag = "9")]
        SubOrchestrationInstanceCreated(super::SubOrchestrationInstanceCreatedEvent),
        #[prost(message, tag = "10")]
        SubOrchestrationInstanceCompleted(super::SubOrchestrationInstanceCompletedEvent),
        #[prost(message, tag = "11")]
        SubOrchestrationInstanceFailed(super::SubOrchestrationInstanceFailedEvent),
        #[prost(message, tag = "12")]
        TimerCreated(super::TimerCreatedEvent),
        #[prost(message, tag = "13")]
        TimerFired(super::TimerFiredEvent),
        #[prost(message, tag = "14")]
        OrchestratorStarted(super::OrchestratorStartedEvent),
        #[prost(message, tag = "15")]
        OrchestratorCompleted(super::OrchestratorCompletedEvent),
        #[prost(message, tag = "16")]
        EventSent(super::EventSentEvent),
        #[prost(message, tag = "17")]
        EventRaised(super::EventRaisedEvent),
        #[prost(message, tag = "18")]
        GenericEvent(super::GenericEvent),
        #[prost(message, tag = "19")]
        HistoryState(super::HistoryStateEvent),
        #[prost(message, tag = "20")]
        ContinueAsNew(super::ContinueAsNewEvent),
        #[prost(message, tag = "21")]
        ExecutionSuspended(super::ExecutionSuspendedEvent),
        #[prost(message, tag = "22")]
        ExecutionResumed(super::ExecutionResumedEvent),
    }
}
impl ::prost::Name for HistoryEvent {
    const NAME: &'static str = "HistoryEvent";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "HistoryEvent".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/HistoryEvent".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ScheduleTaskAction {
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub version: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "3")]
    pub input: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for ScheduleTaskAction {
    const NAME: &'static str = "ScheduleTaskAction";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "ScheduleTaskAction".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ScheduleTaskAction".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateSubOrchestrationAction {
    #[prost(string, tag = "1")]
    pub instance_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub version: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "4")]
    pub input: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for CreateSubOrchestrationAction {
    const NAME: &'static str = "CreateSubOrchestrationAction";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "CreateSubOrchestrationAction".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/CreateSubOrchestrationAction".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct CreateTimerAction {
    #[prost(message, optional, tag = "1")]
    pub fire_at: ::core::option::Option<::prost_wkt_types::Timestamp>,
}
impl ::prost::Name for CreateTimerAction {
    const NAME: &'static str = "CreateTimerAction";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "CreateTimerAction".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/CreateTimerAction".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SendEventAction {
    #[prost(message, optional, tag = "1")]
    pub instance: ::core::option::Option<OrchestrationInstance>,
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub data: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for SendEventAction {
    const NAME: &'static str = "SendEventAction";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "SendEventAction".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/SendEventAction".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CompleteOrchestrationAction {
    #[prost(enumeration = "OrchestrationStatus", tag = "1")]
    pub orchestration_status: i32,
    #[prost(message, optional, tag = "2")]
    pub result: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "3")]
    pub details: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "4")]
    pub new_version: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, repeated, tag = "5")]
    pub carryover_events: ::prost::alloc::vec::Vec<HistoryEvent>,
    #[prost(message, optional, tag = "6")]
    pub failure_details: ::core::option::Option<TaskFailureDetails>,
}
impl ::prost::Name for CompleteOrchestrationAction {
    const NAME: &'static str = "CompleteOrchestrationAction";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "CompleteOrchestrationAction".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/CompleteOrchestrationAction".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TerminateOrchestrationAction {
    #[prost(string, tag = "1")]
    pub instance_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub reason: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(bool, tag = "3")]
    pub recurse: bool,
}
impl ::prost::Name for TerminateOrchestrationAction {
    const NAME: &'static str = "TerminateOrchestrationAction";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "TerminateOrchestrationAction".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/TerminateOrchestrationAction".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OrchestratorAction {
    #[prost(int32, tag = "1")]
    pub id: i32,
    #[prost(
        oneof = "orchestrator_action::OrchestratorActionType",
        tags = "2, 3, 4, 5, 6, 7"
    )]
    pub orchestrator_action_type: ::core::option::Option<
        orchestrator_action::OrchestratorActionType,
    >,
}
/// Nested message and enum types in `OrchestratorAction`.
pub mod orchestrator_action {
    #[derive(serde::Serialize, serde::Deserialize)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum OrchestratorActionType {
        #[prost(message, tag = "2")]
        ScheduleTask(super::ScheduleTaskAction),
        #[prost(message, tag = "3")]
        CreateSubOrchestration(super::CreateSubOrchestrationAction),
        #[prost(message, tag = "4")]
        CreateTimer(super::CreateTimerAction),
        #[prost(message, tag = "5")]
        SendEvent(super::SendEventAction),
        #[prost(message, tag = "6")]
        CompleteOrchestration(super::CompleteOrchestrationAction),
        #[prost(message, tag = "7")]
        TerminateOrchestration(super::TerminateOrchestrationAction),
    }
}
impl ::prost::Name for OrchestratorAction {
    const NAME: &'static str = "OrchestratorAction";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "OrchestratorAction".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/OrchestratorAction".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OrchestratorRequest {
    #[prost(string, tag = "1")]
    pub instance_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub execution_id: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, repeated, tag = "3")]
    pub past_events: ::prost::alloc::vec::Vec<HistoryEvent>,
    #[prost(message, repeated, tag = "4")]
    pub new_events: ::prost::alloc::vec::Vec<HistoryEvent>,
    #[prost(message, optional, tag = "5")]
    pub entity_parameters: ::core::option::Option<OrchestratorEntityParameters>,
}
impl ::prost::Name for OrchestratorRequest {
    const NAME: &'static str = "OrchestratorRequest";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "OrchestratorRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/OrchestratorRequest".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OrchestratorResponse {
    #[prost(string, tag = "1")]
    pub instance_id: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "2")]
    pub actions: ::prost::alloc::vec::Vec<OrchestratorAction>,
    #[prost(message, optional, tag = "3")]
    pub custom_status: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for OrchestratorResponse {
    const NAME: &'static str = "OrchestratorResponse";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "OrchestratorResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/OrchestratorResponse".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateInstanceRequest {
    #[prost(string, tag = "1")]
    pub instance_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub version: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "4")]
    pub input: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "5")]
    pub scheduled_start_timestamp: ::core::option::Option<::prost_wkt_types::Timestamp>,
    #[prost(message, optional, tag = "6")]
    pub orchestration_id_reuse_policy: ::core::option::Option<
        OrchestrationIdReusePolicy,
    >,
}
impl ::prost::Name for CreateInstanceRequest {
    const NAME: &'static str = "CreateInstanceRequest";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "CreateInstanceRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/CreateInstanceRequest".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OrchestrationIdReusePolicy {
    #[prost(enumeration = "OrchestrationStatus", repeated, tag = "1")]
    pub operation_status: ::prost::alloc::vec::Vec<i32>,
    #[prost(enumeration = "CreateOrchestrationAction", tag = "2")]
    pub action: i32,
}
impl ::prost::Name for OrchestrationIdReusePolicy {
    const NAME: &'static str = "OrchestrationIdReusePolicy";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "OrchestrationIdReusePolicy".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/OrchestrationIdReusePolicy".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateInstanceResponse {
    #[prost(string, tag = "1")]
    pub instance_id: ::prost::alloc::string::String,
}
impl ::prost::Name for CreateInstanceResponse {
    const NAME: &'static str = "CreateInstanceResponse";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "CreateInstanceResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/CreateInstanceResponse".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetInstanceRequest {
    #[prost(string, tag = "1")]
    pub instance_id: ::prost::alloc::string::String,
    #[prost(bool, tag = "2")]
    pub get_inputs_and_outputs: bool,
}
impl ::prost::Name for GetInstanceRequest {
    const NAME: &'static str = "GetInstanceRequest";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "GetInstanceRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/GetInstanceRequest".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetInstanceResponse {
    #[prost(bool, tag = "1")]
    pub exists: bool,
    #[prost(message, optional, tag = "2")]
    pub orchestration_state: ::core::option::Option<OrchestrationState>,
}
impl ::prost::Name for GetInstanceResponse {
    const NAME: &'static str = "GetInstanceResponse";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "GetInstanceResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/GetInstanceResponse".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RewindInstanceRequest {
    #[prost(string, tag = "1")]
    pub instance_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub reason: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for RewindInstanceRequest {
    const NAME: &'static str = "RewindInstanceRequest";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "RewindInstanceRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RewindInstanceRequest".into()
    }
}
/// Empty for now. Using explicit type incase we want to add content later.
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct RewindInstanceResponse {}
impl ::prost::Name for RewindInstanceResponse {
    const NAME: &'static str = "RewindInstanceResponse";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "RewindInstanceResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RewindInstanceResponse".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OrchestrationState {
    #[prost(string, tag = "1")]
    pub instance_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub version: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(enumeration = "OrchestrationStatus", tag = "4")]
    pub orchestration_status: i32,
    #[prost(message, optional, tag = "5")]
    pub scheduled_start_timestamp: ::core::option::Option<::prost_wkt_types::Timestamp>,
    #[prost(message, optional, tag = "6")]
    pub created_timestamp: ::core::option::Option<::prost_wkt_types::Timestamp>,
    #[prost(message, optional, tag = "7")]
    pub last_updated_timestamp: ::core::option::Option<::prost_wkt_types::Timestamp>,
    #[prost(message, optional, tag = "8")]
    pub input: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "9")]
    pub output: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "10")]
    pub custom_status: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "11")]
    pub failure_details: ::core::option::Option<TaskFailureDetails>,
}
impl ::prost::Name for OrchestrationState {
    const NAME: &'static str = "OrchestrationState";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "OrchestrationState".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/OrchestrationState".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RaiseEventRequest {
    #[prost(string, tag = "1")]
    pub instance_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub input: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for RaiseEventRequest {
    const NAME: &'static str = "RaiseEventRequest";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "RaiseEventRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RaiseEventRequest".into()
    }
}
/// No payload
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct RaiseEventResponse {}
impl ::prost::Name for RaiseEventResponse {
    const NAME: &'static str = "RaiseEventResponse";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "RaiseEventResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/RaiseEventResponse".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TerminateRequest {
    #[prost(string, tag = "1")]
    pub instance_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub output: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(bool, tag = "3")]
    pub recursive: bool,
}
impl ::prost::Name for TerminateRequest {
    const NAME: &'static str = "TerminateRequest";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "TerminateRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/TerminateRequest".into()
    }
}
/// No payload
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct TerminateResponse {}
impl ::prost::Name for TerminateResponse {
    const NAME: &'static str = "TerminateResponse";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "TerminateResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/TerminateResponse".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SuspendRequest {
    #[prost(string, tag = "1")]
    pub instance_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub reason: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for SuspendRequest {
    const NAME: &'static str = "SuspendRequest";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "SuspendRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/SuspendRequest".into()
    }
}
/// No payload
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct SuspendResponse {}
impl ::prost::Name for SuspendResponse {
    const NAME: &'static str = "SuspendResponse";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "SuspendResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/SuspendResponse".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResumeRequest {
    #[prost(string, tag = "1")]
    pub instance_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub reason: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for ResumeRequest {
    const NAME: &'static str = "ResumeRequest";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "ResumeRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ResumeRequest".into()
    }
}
/// No payload
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ResumeResponse {}
impl ::prost::Name for ResumeResponse {
    const NAME: &'static str = "ResumeResponse";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "ResumeResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ResumeResponse".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryInstancesRequest {
    #[prost(message, optional, tag = "1")]
    pub query: ::core::option::Option<InstanceQuery>,
}
impl ::prost::Name for QueryInstancesRequest {
    const NAME: &'static str = "QueryInstancesRequest";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "QueryInstancesRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/QueryInstancesRequest".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InstanceQuery {
    #[prost(enumeration = "OrchestrationStatus", repeated, tag = "1")]
    pub runtime_status: ::prost::alloc::vec::Vec<i32>,
    #[prost(message, optional, tag = "2")]
    pub created_time_from: ::core::option::Option<::prost_wkt_types::Timestamp>,
    #[prost(message, optional, tag = "3")]
    pub created_time_to: ::core::option::Option<::prost_wkt_types::Timestamp>,
    #[prost(message, repeated, tag = "4")]
    pub task_hub_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(int32, tag = "5")]
    pub max_instance_count: i32,
    #[prost(message, optional, tag = "6")]
    pub continuation_token: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "7")]
    pub instance_id_prefix: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(bool, tag = "8")]
    pub fetch_inputs_and_outputs: bool,
}
impl ::prost::Name for InstanceQuery {
    const NAME: &'static str = "InstanceQuery";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "InstanceQuery".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/InstanceQuery".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryInstancesResponse {
    #[prost(message, repeated, tag = "1")]
    pub orchestration_state: ::prost::alloc::vec::Vec<OrchestrationState>,
    #[prost(message, optional, tag = "2")]
    pub continuation_token: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for QueryInstancesResponse {
    const NAME: &'static str = "QueryInstancesResponse";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "QueryInstancesResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/QueryInstancesResponse".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PurgeInstancesRequest {
    #[prost(bool, tag = "3")]
    pub recursive: bool,
    #[prost(oneof = "purge_instances_request::Request", tags = "1, 2")]
    pub request: ::core::option::Option<purge_instances_request::Request>,
}
/// Nested message and enum types in `PurgeInstancesRequest`.
pub mod purge_instances_request {
    #[derive(serde::Serialize, serde::Deserialize)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Request {
        #[prost(string, tag = "1")]
        InstanceId(::prost::alloc::string::String),
        #[prost(message, tag = "2")]
        PurgeInstanceFilter(super::PurgeInstanceFilter),
    }
}
impl ::prost::Name for PurgeInstancesRequest {
    const NAME: &'static str = "PurgeInstancesRequest";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "PurgeInstancesRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/PurgeInstancesRequest".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PurgeInstanceFilter {
    #[prost(message, optional, tag = "1")]
    pub created_time_from: ::core::option::Option<::prost_wkt_types::Timestamp>,
    #[prost(message, optional, tag = "2")]
    pub created_time_to: ::core::option::Option<::prost_wkt_types::Timestamp>,
    #[prost(enumeration = "OrchestrationStatus", repeated, tag = "3")]
    pub runtime_status: ::prost::alloc::vec::Vec<i32>,
}
impl ::prost::Name for PurgeInstanceFilter {
    const NAME: &'static str = "PurgeInstanceFilter";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "PurgeInstanceFilter".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/PurgeInstanceFilter".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct PurgeInstancesResponse {
    #[prost(int32, tag = "1")]
    pub deleted_instance_count: i32,
}
impl ::prost::Name for PurgeInstancesResponse {
    const NAME: &'static str = "PurgeInstancesResponse";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "PurgeInstancesResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/PurgeInstancesResponse".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct CreateTaskHubRequest {
    #[prost(bool, tag = "1")]
    pub recreate_if_exists: bool,
}
impl ::prost::Name for CreateTaskHubRequest {
    const NAME: &'static str = "CreateTaskHubRequest";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "CreateTaskHubRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/CreateTaskHubRequest".into()
    }
}
/// no playload
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct CreateTaskHubResponse {}
impl ::prost::Name for CreateTaskHubResponse {
    const NAME: &'static str = "CreateTaskHubResponse";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "CreateTaskHubResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/CreateTaskHubResponse".into()
    }
}
/// no playload
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct DeleteTaskHubRequest {}
impl ::prost::Name for DeleteTaskHubRequest {
    const NAME: &'static str = "DeleteTaskHubRequest";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "DeleteTaskHubRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/DeleteTaskHubRequest".into()
    }
}
/// no playload
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct DeleteTaskHubResponse {}
impl ::prost::Name for DeleteTaskHubResponse {
    const NAME: &'static str = "DeleteTaskHubResponse";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "DeleteTaskHubResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/DeleteTaskHubResponse".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SignalEntityRequest {
    #[prost(string, tag = "1")]
    pub instance_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub input: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(string, tag = "4")]
    pub request_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "5")]
    pub scheduled_time: ::core::option::Option<::prost_wkt_types::Timestamp>,
}
impl ::prost::Name for SignalEntityRequest {
    const NAME: &'static str = "SignalEntityRequest";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "SignalEntityRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/SignalEntityRequest".into()
    }
}
/// no payload
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct SignalEntityResponse {}
impl ::prost::Name for SignalEntityResponse {
    const NAME: &'static str = "SignalEntityResponse";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "SignalEntityResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/SignalEntityResponse".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetEntityRequest {
    #[prost(string, tag = "1")]
    pub instance_id: ::prost::alloc::string::String,
    #[prost(bool, tag = "2")]
    pub include_state: bool,
}
impl ::prost::Name for GetEntityRequest {
    const NAME: &'static str = "GetEntityRequest";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "GetEntityRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/GetEntityRequest".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetEntityResponse {
    #[prost(bool, tag = "1")]
    pub exists: bool,
    #[prost(message, optional, tag = "2")]
    pub entity: ::core::option::Option<EntityMetadata>,
}
impl ::prost::Name for GetEntityResponse {
    const NAME: &'static str = "GetEntityResponse";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "GetEntityResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/GetEntityResponse".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EntityQuery {
    #[prost(message, optional, tag = "1")]
    pub instance_id_starts_with: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "2")]
    pub last_modified_from: ::core::option::Option<::prost_wkt_types::Timestamp>,
    #[prost(message, optional, tag = "3")]
    pub last_modified_to: ::core::option::Option<::prost_wkt_types::Timestamp>,
    #[prost(bool, tag = "4")]
    pub include_state: bool,
    #[prost(bool, tag = "5")]
    pub include_transient: bool,
    #[prost(message, optional, tag = "6")]
    pub page_size: ::core::option::Option<i32>,
    #[prost(message, optional, tag = "7")]
    pub continuation_token: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for EntityQuery {
    const NAME: &'static str = "EntityQuery";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "EntityQuery".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/EntityQuery".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryEntitiesRequest {
    #[prost(message, optional, tag = "1")]
    pub query: ::core::option::Option<EntityQuery>,
}
impl ::prost::Name for QueryEntitiesRequest {
    const NAME: &'static str = "QueryEntitiesRequest";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "QueryEntitiesRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/QueryEntitiesRequest".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryEntitiesResponse {
    #[prost(message, repeated, tag = "1")]
    pub entities: ::prost::alloc::vec::Vec<EntityMetadata>,
    #[prost(message, optional, tag = "2")]
    pub continuation_token: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for QueryEntitiesResponse {
    const NAME: &'static str = "QueryEntitiesResponse";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "QueryEntitiesResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/QueryEntitiesResponse".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EntityMetadata {
    #[prost(string, tag = "1")]
    pub instance_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub last_modified_time: ::core::option::Option<::prost_wkt_types::Timestamp>,
    #[prost(int32, tag = "3")]
    pub backlog_queue_size: i32,
    #[prost(message, optional, tag = "4")]
    pub locked_by: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "5")]
    pub serialized_state: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for EntityMetadata {
    const NAME: &'static str = "EntityMetadata";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "EntityMetadata".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/EntityMetadata".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CleanEntityStorageRequest {
    #[prost(message, optional, tag = "1")]
    pub continuation_token: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(bool, tag = "2")]
    pub remove_empty_entities: bool,
    #[prost(bool, tag = "3")]
    pub release_orphaned_locks: bool,
}
impl ::prost::Name for CleanEntityStorageRequest {
    const NAME: &'static str = "CleanEntityStorageRequest";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "CleanEntityStorageRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/CleanEntityStorageRequest".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CleanEntityStorageResponse {
    #[prost(message, optional, tag = "1")]
    pub continuation_token: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(int32, tag = "2")]
    pub empty_entities_removed: i32,
    #[prost(int32, tag = "3")]
    pub orphaned_locks_released: i32,
}
impl ::prost::Name for CleanEntityStorageResponse {
    const NAME: &'static str = "CleanEntityStorageResponse";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "CleanEntityStorageResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/CleanEntityStorageResponse".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct OrchestratorEntityParameters {
    #[prost(message, optional, tag = "1")]
    pub entity_message_reorder_window: ::core::option::Option<
        ::prost_wkt_types::Duration,
    >,
}
impl ::prost::Name for OrchestratorEntityParameters {
    const NAME: &'static str = "OrchestratorEntityParameters";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "OrchestratorEntityParameters".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/OrchestratorEntityParameters".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EntityBatchRequest {
    #[prost(string, tag = "1")]
    pub instance_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub entity_state: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, repeated, tag = "3")]
    pub operations: ::prost::alloc::vec::Vec<OperationRequest>,
}
impl ::prost::Name for EntityBatchRequest {
    const NAME: &'static str = "EntityBatchRequest";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "EntityBatchRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/EntityBatchRequest".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EntityBatchResult {
    #[prost(message, repeated, tag = "1")]
    pub results: ::prost::alloc::vec::Vec<OperationResult>,
    #[prost(message, repeated, tag = "2")]
    pub actions: ::prost::alloc::vec::Vec<OperationAction>,
    #[prost(message, optional, tag = "3")]
    pub entity_state: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "4")]
    pub failure_details: ::core::option::Option<TaskFailureDetails>,
}
impl ::prost::Name for EntityBatchResult {
    const NAME: &'static str = "EntityBatchResult";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "EntityBatchResult".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/EntityBatchResult".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OperationRequest {
    #[prost(string, tag = "1")]
    pub operation: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub request_id: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub input: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for OperationRequest {
    const NAME: &'static str = "OperationRequest";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "OperationRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/OperationRequest".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OperationResult {
    #[prost(oneof = "operation_result::ResultType", tags = "1, 2")]
    pub result_type: ::core::option::Option<operation_result::ResultType>,
}
/// Nested message and enum types in `OperationResult`.
pub mod operation_result {
    #[derive(serde::Serialize, serde::Deserialize)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum ResultType {
        #[prost(message, tag = "1")]
        Success(super::OperationResultSuccess),
        #[prost(message, tag = "2")]
        Failure(super::OperationResultFailure),
    }
}
impl ::prost::Name for OperationResult {
    const NAME: &'static str = "OperationResult";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "OperationResult".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/OperationResult".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OperationResultSuccess {
    #[prost(message, optional, tag = "1")]
    pub result: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for OperationResultSuccess {
    const NAME: &'static str = "OperationResultSuccess";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "OperationResultSuccess".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/OperationResultSuccess".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OperationResultFailure {
    #[prost(message, optional, tag = "1")]
    pub failure_details: ::core::option::Option<TaskFailureDetails>,
}
impl ::prost::Name for OperationResultFailure {
    const NAME: &'static str = "OperationResultFailure";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "OperationResultFailure".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/OperationResultFailure".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OperationAction {
    #[prost(int32, tag = "1")]
    pub id: i32,
    #[prost(oneof = "operation_action::OperationActionType", tags = "2, 3")]
    pub operation_action_type: ::core::option::Option<
        operation_action::OperationActionType,
    >,
}
/// Nested message and enum types in `OperationAction`.
pub mod operation_action {
    #[derive(serde::Serialize, serde::Deserialize)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum OperationActionType {
        #[prost(message, tag = "2")]
        SendSignal(super::SendSignalAction),
        #[prost(message, tag = "3")]
        StartNewOrchestration(super::StartNewOrchestrationAction),
    }
}
impl ::prost::Name for OperationAction {
    const NAME: &'static str = "OperationAction";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "OperationAction".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/OperationAction".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SendSignalAction {
    #[prost(string, tag = "1")]
    pub instance_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub input: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "4")]
    pub scheduled_time: ::core::option::Option<::prost_wkt_types::Timestamp>,
}
impl ::prost::Name for SendSignalAction {
    const NAME: &'static str = "SendSignalAction";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "SendSignalAction".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/SendSignalAction".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StartNewOrchestrationAction {
    #[prost(string, tag = "1")]
    pub instance_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "3")]
    pub version: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "4")]
    pub input: ::core::option::Option<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "5")]
    pub scheduled_time: ::core::option::Option<::prost_wkt_types::Timestamp>,
}
impl ::prost::Name for StartNewOrchestrationAction {
    const NAME: &'static str = "StartNewOrchestrationAction";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "StartNewOrchestrationAction".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/StartNewOrchestrationAction".into()
    }
}
/// No parameters currently
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct GetWorkItemsRequest {}
impl ::prost::Name for GetWorkItemsRequest {
    const NAME: &'static str = "GetWorkItemsRequest";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "GetWorkItemsRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/GetWorkItemsRequest".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WorkItem {
    #[prost(oneof = "work_item::Request", tags = "1, 2, 3")]
    pub request: ::core::option::Option<work_item::Request>,
}
/// Nested message and enum types in `WorkItem`.
pub mod work_item {
    #[derive(serde::Serialize, serde::Deserialize)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Request {
        #[prost(message, tag = "1")]
        OrchestratorRequest(super::OrchestratorRequest),
        #[prost(message, tag = "2")]
        ActivityRequest(super::ActivityRequest),
        #[prost(message, tag = "3")]
        EntityRequest(super::EntityBatchRequest),
    }
}
impl ::prost::Name for WorkItem {
    const NAME: &'static str = "WorkItem";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "WorkItem".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/WorkItem".into()
    }
}
/// No payload
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct CompleteTaskResponse {}
impl ::prost::Name for CompleteTaskResponse {
    const NAME: &'static str = "CompleteTaskResponse";
    const PACKAGE: &'static str = "";
    fn full_name() -> ::prost::alloc::string::String {
        "CompleteTaskResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/CompleteTaskResponse".into()
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum OrchestrationStatus {
    Running = 0,
    Completed = 1,
    ContinuedAsNew = 2,
    Failed = 3,
    Canceled = 4,
    Terminated = 5,
    Pending = 6,
    Suspended = 7,
}
impl OrchestrationStatus {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Running => "ORCHESTRATION_STATUS_RUNNING",
            Self::Completed => "ORCHESTRATION_STATUS_COMPLETED",
            Self::ContinuedAsNew => "ORCHESTRATION_STATUS_CONTINUED_AS_NEW",
            Self::Failed => "ORCHESTRATION_STATUS_FAILED",
            Self::Canceled => "ORCHESTRATION_STATUS_CANCELED",
            Self::Terminated => "ORCHESTRATION_STATUS_TERMINATED",
            Self::Pending => "ORCHESTRATION_STATUS_PENDING",
            Self::Suspended => "ORCHESTRATION_STATUS_SUSPENDED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "ORCHESTRATION_STATUS_RUNNING" => Some(Self::Running),
            "ORCHESTRATION_STATUS_COMPLETED" => Some(Self::Completed),
            "ORCHESTRATION_STATUS_CONTINUED_AS_NEW" => Some(Self::ContinuedAsNew),
            "ORCHESTRATION_STATUS_FAILED" => Some(Self::Failed),
            "ORCHESTRATION_STATUS_CANCELED" => Some(Self::Canceled),
            "ORCHESTRATION_STATUS_TERMINATED" => Some(Self::Terminated),
            "ORCHESTRATION_STATUS_PENDING" => Some(Self::Pending),
            "ORCHESTRATION_STATUS_SUSPENDED" => Some(Self::Suspended),
            _ => None,
        }
    }
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum CreateOrchestrationAction {
    Error = 0,
    Ignore = 1,
    Terminate = 2,
}
impl CreateOrchestrationAction {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Error => "ERROR",
            Self::Ignore => "IGNORE",
            Self::Terminate => "TERMINATE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "ERROR" => Some(Self::Error),
            "IGNORE" => Some(Self::Ignore),
            "TERMINATE" => Some(Self::Terminate),
            _ => None,
        }
    }
}
/// Generated client implementations.
pub mod task_hub_sidecar_service_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    #[derive(Debug, Clone)]
    pub struct TaskHubSidecarServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl TaskHubSidecarServiceClient<tonic::transport::Channel> {
        /// 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: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> TaskHubSidecarServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> TaskHubSidecarServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            TaskHubSidecarServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Sends a hello request to the sidecar service.
        pub async fn hello(
            &mut self,
            request: impl tonic::IntoRequest<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/TaskHubSidecarService/Hello",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("TaskHubSidecarService", "Hello"));
            self.inner.unary(req, path, codec).await
        }
        /// Starts a new orchestration instance.
        pub async fn start_instance(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateInstanceRequest>,
        ) -> std::result::Result<
            tonic::Response<super::CreateInstanceResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/TaskHubSidecarService/StartInstance",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("TaskHubSidecarService", "StartInstance"));
            self.inner.unary(req, path, codec).await
        }
        /// Gets the status of an existing orchestration instance.
        pub async fn get_instance(
            &mut self,
            request: impl tonic::IntoRequest<super::GetInstanceRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetInstanceResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/TaskHubSidecarService/GetInstance",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("TaskHubSidecarService", "GetInstance"));
            self.inner.unary(req, path, codec).await
        }
        /// Rewinds an orchestration instance to last known good state and replays from there.
        pub async fn rewind_instance(
            &mut self,
            request: impl tonic::IntoRequest<super::RewindInstanceRequest>,
        ) -> std::result::Result<
            tonic::Response<super::RewindInstanceResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/TaskHubSidecarService/RewindInstance",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("TaskHubSidecarService", "RewindInstance"));
            self.inner.unary(req, path, codec).await
        }
        /// Waits for an orchestration instance to reach a running or completion state.
        pub async fn wait_for_instance_start(
            &mut self,
            request: impl tonic::IntoRequest<super::GetInstanceRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetInstanceResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/TaskHubSidecarService/WaitForInstanceStart",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("TaskHubSidecarService", "WaitForInstanceStart"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Waits for an orchestration instance to reach a completion state (completed, failed, terminated, etc.).
        pub async fn wait_for_instance_completion(
            &mut self,
            request: impl tonic::IntoRequest<super::GetInstanceRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetInstanceResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/TaskHubSidecarService/WaitForInstanceCompletion",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("TaskHubSidecarService", "WaitForInstanceCompletion"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Raises an event to a running orchestration instance.
        pub async fn raise_event(
            &mut self,
            request: impl tonic::IntoRequest<super::RaiseEventRequest>,
        ) -> std::result::Result<
            tonic::Response<super::RaiseEventResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/TaskHubSidecarService/RaiseEvent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("TaskHubSidecarService", "RaiseEvent"));
            self.inner.unary(req, path, codec).await
        }
        /// Terminates a running orchestration instance.
        pub async fn terminate_instance(
            &mut self,
            request: impl tonic::IntoRequest<super::TerminateRequest>,
        ) -> std::result::Result<
            tonic::Response<super::TerminateResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/TaskHubSidecarService/TerminateInstance",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("TaskHubSidecarService", "TerminateInstance"));
            self.inner.unary(req, path, codec).await
        }
        /// Suspends a running orchestration instance.
        pub async fn suspend_instance(
            &mut self,
            request: impl tonic::IntoRequest<super::SuspendRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SuspendResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/TaskHubSidecarService/SuspendInstance",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("TaskHubSidecarService", "SuspendInstance"));
            self.inner.unary(req, path, codec).await
        }
        /// Resumes a suspended orchestration instance.
        pub async fn resume_instance(
            &mut self,
            request: impl tonic::IntoRequest<super::ResumeRequest>,
        ) -> std::result::Result<tonic::Response<super::ResumeResponse>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/TaskHubSidecarService/ResumeInstance",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("TaskHubSidecarService", "ResumeInstance"));
            self.inner.unary(req, path, codec).await
        }
        pub async fn query_instances(
            &mut self,
            request: impl tonic::IntoRequest<super::QueryInstancesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::QueryInstancesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/TaskHubSidecarService/QueryInstances",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("TaskHubSidecarService", "QueryInstances"));
            self.inner.unary(req, path, codec).await
        }
        pub async fn purge_instances(
            &mut self,
            request: impl tonic::IntoRequest<super::PurgeInstancesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::PurgeInstancesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/TaskHubSidecarService/PurgeInstances",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("TaskHubSidecarService", "PurgeInstances"));
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_work_items(
            &mut self,
            request: impl tonic::IntoRequest<super::GetWorkItemsRequest>,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::WorkItem>>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/TaskHubSidecarService/GetWorkItems",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("TaskHubSidecarService", "GetWorkItems"));
            self.inner.server_streaming(req, path, codec).await
        }
        pub async fn complete_activity_task(
            &mut self,
            request: impl tonic::IntoRequest<super::ActivityResponse>,
        ) -> std::result::Result<
            tonic::Response<super::CompleteTaskResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/TaskHubSidecarService/CompleteActivityTask",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("TaskHubSidecarService", "CompleteActivityTask"),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn complete_orchestrator_task(
            &mut self,
            request: impl tonic::IntoRequest<super::OrchestratorResponse>,
        ) -> std::result::Result<
            tonic::Response<super::CompleteTaskResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/TaskHubSidecarService/CompleteOrchestratorTask",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("TaskHubSidecarService", "CompleteOrchestratorTask"),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn complete_entity_task(
            &mut self,
            request: impl tonic::IntoRequest<super::EntityBatchResult>,
        ) -> std::result::Result<
            tonic::Response<super::CompleteTaskResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/TaskHubSidecarService/CompleteEntityTask",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("TaskHubSidecarService", "CompleteEntityTask"));
            self.inner.unary(req, path, codec).await
        }
        /// Deletes and Creates the necessary resources for the orchestration service and the instance store
        pub async fn create_task_hub(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateTaskHubRequest>,
        ) -> std::result::Result<
            tonic::Response<super::CreateTaskHubResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/TaskHubSidecarService/CreateTaskHub",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("TaskHubSidecarService", "CreateTaskHub"));
            self.inner.unary(req, path, codec).await
        }
        /// Deletes the resources for the orchestration service and optionally the instance store
        pub async fn delete_task_hub(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteTaskHubRequest>,
        ) -> std::result::Result<
            tonic::Response<super::DeleteTaskHubResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/TaskHubSidecarService/DeleteTaskHub",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("TaskHubSidecarService", "DeleteTaskHub"));
            self.inner.unary(req, path, codec).await
        }
        /// sends a signal to an entity
        pub async fn signal_entity(
            &mut self,
            request: impl tonic::IntoRequest<super::SignalEntityRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SignalEntityResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/TaskHubSidecarService/SignalEntity",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("TaskHubSidecarService", "SignalEntity"));
            self.inner.unary(req, path, codec).await
        }
        /// get information about a specific entity
        pub async fn get_entity(
            &mut self,
            request: impl tonic::IntoRequest<super::GetEntityRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetEntityResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/TaskHubSidecarService/GetEntity",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("TaskHubSidecarService", "GetEntity"));
            self.inner.unary(req, path, codec).await
        }
        /// query entities
        pub async fn query_entities(
            &mut self,
            request: impl tonic::IntoRequest<super::QueryEntitiesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::QueryEntitiesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/TaskHubSidecarService/QueryEntities",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("TaskHubSidecarService", "QueryEntities"));
            self.inner.unary(req, path, codec).await
        }
        /// clean entity storage
        pub async fn clean_entity_storage(
            &mut self,
            request: impl tonic::IntoRequest<super::CleanEntityStorageRequest>,
        ) -> std::result::Result<
            tonic::Response<super::CleanEntityStorageResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/TaskHubSidecarService/CleanEntityStorage",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("TaskHubSidecarService", "CleanEntityStorage"));
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Generated server implementations.
pub mod task_hub_sidecar_service_server {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    /// Generated trait containing gRPC methods that should be implemented for use with TaskHubSidecarServiceServer.
    #[async_trait]
    pub trait TaskHubSidecarService: std::marker::Send + std::marker::Sync + 'static {
        /// Sends a hello request to the sidecar service.
        async fn hello(
            &self,
            request: tonic::Request<()>,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status>;
        /// Starts a new orchestration instance.
        async fn start_instance(
            &self,
            request: tonic::Request<super::CreateInstanceRequest>,
        ) -> std::result::Result<
            tonic::Response<super::CreateInstanceResponse>,
            tonic::Status,
        >;
        /// Gets the status of an existing orchestration instance.
        async fn get_instance(
            &self,
            request: tonic::Request<super::GetInstanceRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetInstanceResponse>,
            tonic::Status,
        >;
        /// Rewinds an orchestration instance to last known good state and replays from there.
        async fn rewind_instance(
            &self,
            request: tonic::Request<super::RewindInstanceRequest>,
        ) -> std::result::Result<
            tonic::Response<super::RewindInstanceResponse>,
            tonic::Status,
        >;
        /// Waits for an orchestration instance to reach a running or completion state.
        async fn wait_for_instance_start(
            &self,
            request: tonic::Request<super::GetInstanceRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetInstanceResponse>,
            tonic::Status,
        >;
        /// Waits for an orchestration instance to reach a completion state (completed, failed, terminated, etc.).
        async fn wait_for_instance_completion(
            &self,
            request: tonic::Request<super::GetInstanceRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetInstanceResponse>,
            tonic::Status,
        >;
        /// Raises an event to a running orchestration instance.
        async fn raise_event(
            &self,
            request: tonic::Request<super::RaiseEventRequest>,
        ) -> std::result::Result<
            tonic::Response<super::RaiseEventResponse>,
            tonic::Status,
        >;
        /// Terminates a running orchestration instance.
        async fn terminate_instance(
            &self,
            request: tonic::Request<super::TerminateRequest>,
        ) -> std::result::Result<
            tonic::Response<super::TerminateResponse>,
            tonic::Status,
        >;
        /// Suspends a running orchestration instance.
        async fn suspend_instance(
            &self,
            request: tonic::Request<super::SuspendRequest>,
        ) -> std::result::Result<tonic::Response<super::SuspendResponse>, tonic::Status>;
        /// Resumes a suspended orchestration instance.
        async fn resume_instance(
            &self,
            request: tonic::Request<super::ResumeRequest>,
        ) -> std::result::Result<tonic::Response<super::ResumeResponse>, tonic::Status>;
        async fn query_instances(
            &self,
            request: tonic::Request<super::QueryInstancesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::QueryInstancesResponse>,
            tonic::Status,
        >;
        async fn purge_instances(
            &self,
            request: tonic::Request<super::PurgeInstancesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::PurgeInstancesResponse>,
            tonic::Status,
        >;
        /// Server streaming response type for the GetWorkItems method.
        type GetWorkItemsStream: tonic::codegen::tokio_stream::Stream<
                Item = std::result::Result<super::WorkItem, tonic::Status>,
            >
            + std::marker::Send
            + 'static;
        async fn get_work_items(
            &self,
            request: tonic::Request<super::GetWorkItemsRequest>,
        ) -> std::result::Result<
            tonic::Response<Self::GetWorkItemsStream>,
            tonic::Status,
        >;
        async fn complete_activity_task(
            &self,
            request: tonic::Request<super::ActivityResponse>,
        ) -> std::result::Result<
            tonic::Response<super::CompleteTaskResponse>,
            tonic::Status,
        >;
        async fn complete_orchestrator_task(
            &self,
            request: tonic::Request<super::OrchestratorResponse>,
        ) -> std::result::Result<
            tonic::Response<super::CompleteTaskResponse>,
            tonic::Status,
        >;
        async fn complete_entity_task(
            &self,
            request: tonic::Request<super::EntityBatchResult>,
        ) -> std::result::Result<
            tonic::Response<super::CompleteTaskResponse>,
            tonic::Status,
        >;
        /// Deletes and Creates the necessary resources for the orchestration service and the instance store
        async fn create_task_hub(
            &self,
            request: tonic::Request<super::CreateTaskHubRequest>,
        ) -> std::result::Result<
            tonic::Response<super::CreateTaskHubResponse>,
            tonic::Status,
        >;
        /// Deletes the resources for the orchestration service and optionally the instance store
        async fn delete_task_hub(
            &self,
            request: tonic::Request<super::DeleteTaskHubRequest>,
        ) -> std::result::Result<
            tonic::Response<super::DeleteTaskHubResponse>,
            tonic::Status,
        >;
        /// sends a signal to an entity
        async fn signal_entity(
            &self,
            request: tonic::Request<super::SignalEntityRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SignalEntityResponse>,
            tonic::Status,
        >;
        /// get information about a specific entity
        async fn get_entity(
            &self,
            request: tonic::Request<super::GetEntityRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetEntityResponse>,
            tonic::Status,
        >;
        /// query entities
        async fn query_entities(
            &self,
            request: tonic::Request<super::QueryEntitiesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::QueryEntitiesResponse>,
            tonic::Status,
        >;
        /// clean entity storage
        async fn clean_entity_storage(
            &self,
            request: tonic::Request<super::CleanEntityStorageRequest>,
        ) -> std::result::Result<
            tonic::Response<super::CleanEntityStorageResponse>,
            tonic::Status,
        >;
    }
    #[derive(Debug)]
    pub struct TaskHubSidecarServiceServer<T> {
        inner: Arc<T>,
        accept_compression_encodings: EnabledCompressionEncodings,
        send_compression_encodings: EnabledCompressionEncodings,
        max_decoding_message_size: Option<usize>,
        max_encoding_message_size: Option<usize>,
    }
    impl<T> TaskHubSidecarServiceServer<T> {
        pub fn new(inner: T) -> Self {
            Self::from_arc(Arc::new(inner))
        }
        pub fn from_arc(inner: Arc<T>) -> Self {
            Self {
                inner,
                accept_compression_encodings: Default::default(),
                send_compression_encodings: Default::default(),
                max_decoding_message_size: None,
                max_encoding_message_size: None,
            }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> InterceptedService<Self, F>
        where
            F: tonic::service::Interceptor,
        {
            InterceptedService::new(Self::new(inner), interceptor)
        }
        /// Enable decompressing requests with the given encoding.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.accept_compression_encodings.enable(encoding);
            self
        }
        /// Compress responses with the given encoding, if the client supports it.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.send_compression_encodings.enable(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.max_decoding_message_size = Some(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.max_encoding_message_size = Some(limit);
            self
        }
    }
    impl<T, B> tonic::codegen::Service<http::Request<B>>
    for TaskHubSidecarServiceServer<T>
    where
        T: TaskHubSidecarService,
        B: Body + std::marker::Send + 'static,
        B::Error: Into<StdError> + std::marker::Send + 'static,
    {
        type Response = http::Response<tonic::body::BoxBody>;
        type Error = std::convert::Infallible;
        type Future = BoxFuture<Self::Response, Self::Error>;
        fn poll_ready(
            &mut self,
            _cx: &mut Context<'_>,
        ) -> Poll<std::result::Result<(), Self::Error>> {
            Poll::Ready(Ok(()))
        }
        fn call(&mut self, req: http::Request<B>) -> Self::Future {
            match req.uri().path() {
                "/TaskHubSidecarService/Hello" => {
                    #[allow(non_camel_case_types)]
                    struct HelloSvc<T: TaskHubSidecarService>(pub Arc<T>);
                    impl<T: TaskHubSidecarService> tonic::server::UnaryService<()>
                    for HelloSvc<T> {
                        type Response = ();
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(&mut self, request: tonic::Request<()>) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as TaskHubSidecarService>::hello(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = HelloSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/TaskHubSidecarService/StartInstance" => {
                    #[allow(non_camel_case_types)]
                    struct StartInstanceSvc<T: TaskHubSidecarService>(pub Arc<T>);
                    impl<
                        T: TaskHubSidecarService,
                    > tonic::server::UnaryService<super::CreateInstanceRequest>
                    for StartInstanceSvc<T> {
                        type Response = super::CreateInstanceResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::CreateInstanceRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as TaskHubSidecarService>::start_instance(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = StartInstanceSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/TaskHubSidecarService/GetInstance" => {
                    #[allow(non_camel_case_types)]
                    struct GetInstanceSvc<T: TaskHubSidecarService>(pub Arc<T>);
                    impl<
                        T: TaskHubSidecarService,
                    > tonic::server::UnaryService<super::GetInstanceRequest>
                    for GetInstanceSvc<T> {
                        type Response = super::GetInstanceResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetInstanceRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as TaskHubSidecarService>::get_instance(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetInstanceSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/TaskHubSidecarService/RewindInstance" => {
                    #[allow(non_camel_case_types)]
                    struct RewindInstanceSvc<T: TaskHubSidecarService>(pub Arc<T>);
                    impl<
                        T: TaskHubSidecarService,
                    > tonic::server::UnaryService<super::RewindInstanceRequest>
                    for RewindInstanceSvc<T> {
                        type Response = super::RewindInstanceResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::RewindInstanceRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as TaskHubSidecarService>::rewind_instance(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = RewindInstanceSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/TaskHubSidecarService/WaitForInstanceStart" => {
                    #[allow(non_camel_case_types)]
                    struct WaitForInstanceStartSvc<T: TaskHubSidecarService>(pub Arc<T>);
                    impl<
                        T: TaskHubSidecarService,
                    > tonic::server::UnaryService<super::GetInstanceRequest>
                    for WaitForInstanceStartSvc<T> {
                        type Response = super::GetInstanceResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetInstanceRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as TaskHubSidecarService>::wait_for_instance_start(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = WaitForInstanceStartSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/TaskHubSidecarService/WaitForInstanceCompletion" => {
                    #[allow(non_camel_case_types)]
                    struct WaitForInstanceCompletionSvc<T: TaskHubSidecarService>(
                        pub Arc<T>,
                    );
                    impl<
                        T: TaskHubSidecarService,
                    > tonic::server::UnaryService<super::GetInstanceRequest>
                    for WaitForInstanceCompletionSvc<T> {
                        type Response = super::GetInstanceResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetInstanceRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as TaskHubSidecarService>::wait_for_instance_completion(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = WaitForInstanceCompletionSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/TaskHubSidecarService/RaiseEvent" => {
                    #[allow(non_camel_case_types)]
                    struct RaiseEventSvc<T: TaskHubSidecarService>(pub Arc<T>);
                    impl<
                        T: TaskHubSidecarService,
                    > tonic::server::UnaryService<super::RaiseEventRequest>
                    for RaiseEventSvc<T> {
                        type Response = super::RaiseEventResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::RaiseEventRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as TaskHubSidecarService>::raise_event(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = RaiseEventSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/TaskHubSidecarService/TerminateInstance" => {
                    #[allow(non_camel_case_types)]
                    struct TerminateInstanceSvc<T: TaskHubSidecarService>(pub Arc<T>);
                    impl<
                        T: TaskHubSidecarService,
                    > tonic::server::UnaryService<super::TerminateRequest>
                    for TerminateInstanceSvc<T> {
                        type Response = super::TerminateResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::TerminateRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as TaskHubSidecarService>::terminate_instance(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = TerminateInstanceSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/TaskHubSidecarService/SuspendInstance" => {
                    #[allow(non_camel_case_types)]
                    struct SuspendInstanceSvc<T: TaskHubSidecarService>(pub Arc<T>);
                    impl<
                        T: TaskHubSidecarService,
                    > tonic::server::UnaryService<super::SuspendRequest>
                    for SuspendInstanceSvc<T> {
                        type Response = super::SuspendResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::SuspendRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as TaskHubSidecarService>::suspend_instance(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SuspendInstanceSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/TaskHubSidecarService/ResumeInstance" => {
                    #[allow(non_camel_case_types)]
                    struct ResumeInstanceSvc<T: TaskHubSidecarService>(pub Arc<T>);
                    impl<
                        T: TaskHubSidecarService,
                    > tonic::server::UnaryService<super::ResumeRequest>
                    for ResumeInstanceSvc<T> {
                        type Response = super::ResumeResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ResumeRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as TaskHubSidecarService>::resume_instance(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = ResumeInstanceSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/TaskHubSidecarService/QueryInstances" => {
                    #[allow(non_camel_case_types)]
                    struct QueryInstancesSvc<T: TaskHubSidecarService>(pub Arc<T>);
                    impl<
                        T: TaskHubSidecarService,
                    > tonic::server::UnaryService<super::QueryInstancesRequest>
                    for QueryInstancesSvc<T> {
                        type Response = super::QueryInstancesResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::QueryInstancesRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as TaskHubSidecarService>::query_instances(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = QueryInstancesSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/TaskHubSidecarService/PurgeInstances" => {
                    #[allow(non_camel_case_types)]
                    struct PurgeInstancesSvc<T: TaskHubSidecarService>(pub Arc<T>);
                    impl<
                        T: TaskHubSidecarService,
                    > tonic::server::UnaryService<super::PurgeInstancesRequest>
                    for PurgeInstancesSvc<T> {
                        type Response = super::PurgeInstancesResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::PurgeInstancesRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as TaskHubSidecarService>::purge_instances(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = PurgeInstancesSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/TaskHubSidecarService/GetWorkItems" => {
                    #[allow(non_camel_case_types)]
                    struct GetWorkItemsSvc<T: TaskHubSidecarService>(pub Arc<T>);
                    impl<
                        T: TaskHubSidecarService,
                    > tonic::server::ServerStreamingService<super::GetWorkItemsRequest>
                    for GetWorkItemsSvc<T> {
                        type Response = super::WorkItem;
                        type ResponseStream = T::GetWorkItemsStream;
                        type Future = BoxFuture<
                            tonic::Response<Self::ResponseStream>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetWorkItemsRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as TaskHubSidecarService>::get_work_items(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetWorkItemsSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.server_streaming(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/TaskHubSidecarService/CompleteActivityTask" => {
                    #[allow(non_camel_case_types)]
                    struct CompleteActivityTaskSvc<T: TaskHubSidecarService>(pub Arc<T>);
                    impl<
                        T: TaskHubSidecarService,
                    > tonic::server::UnaryService<super::ActivityResponse>
                    for CompleteActivityTaskSvc<T> {
                        type Response = super::CompleteTaskResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ActivityResponse>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as TaskHubSidecarService>::complete_activity_task(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = CompleteActivityTaskSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/TaskHubSidecarService/CompleteOrchestratorTask" => {
                    #[allow(non_camel_case_types)]
                    struct CompleteOrchestratorTaskSvc<T: TaskHubSidecarService>(
                        pub Arc<T>,
                    );
                    impl<
                        T: TaskHubSidecarService,
                    > tonic::server::UnaryService<super::OrchestratorResponse>
                    for CompleteOrchestratorTaskSvc<T> {
                        type Response = super::CompleteTaskResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::OrchestratorResponse>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as TaskHubSidecarService>::complete_orchestrator_task(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = CompleteOrchestratorTaskSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/TaskHubSidecarService/CompleteEntityTask" => {
                    #[allow(non_camel_case_types)]
                    struct CompleteEntityTaskSvc<T: TaskHubSidecarService>(pub Arc<T>);
                    impl<
                        T: TaskHubSidecarService,
                    > tonic::server::UnaryService<super::EntityBatchResult>
                    for CompleteEntityTaskSvc<T> {
                        type Response = super::CompleteTaskResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::EntityBatchResult>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as TaskHubSidecarService>::complete_entity_task(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = CompleteEntityTaskSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/TaskHubSidecarService/CreateTaskHub" => {
                    #[allow(non_camel_case_types)]
                    struct CreateTaskHubSvc<T: TaskHubSidecarService>(pub Arc<T>);
                    impl<
                        T: TaskHubSidecarService,
                    > tonic::server::UnaryService<super::CreateTaskHubRequest>
                    for CreateTaskHubSvc<T> {
                        type Response = super::CreateTaskHubResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::CreateTaskHubRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as TaskHubSidecarService>::create_task_hub(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = CreateTaskHubSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/TaskHubSidecarService/DeleteTaskHub" => {
                    #[allow(non_camel_case_types)]
                    struct DeleteTaskHubSvc<T: TaskHubSidecarService>(pub Arc<T>);
                    impl<
                        T: TaskHubSidecarService,
                    > tonic::server::UnaryService<super::DeleteTaskHubRequest>
                    for DeleteTaskHubSvc<T> {
                        type Response = super::DeleteTaskHubResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::DeleteTaskHubRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as TaskHubSidecarService>::delete_task_hub(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = DeleteTaskHubSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/TaskHubSidecarService/SignalEntity" => {
                    #[allow(non_camel_case_types)]
                    struct SignalEntitySvc<T: TaskHubSidecarService>(pub Arc<T>);
                    impl<
                        T: TaskHubSidecarService,
                    > tonic::server::UnaryService<super::SignalEntityRequest>
                    for SignalEntitySvc<T> {
                        type Response = super::SignalEntityResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::SignalEntityRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as TaskHubSidecarService>::signal_entity(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SignalEntitySvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/TaskHubSidecarService/GetEntity" => {
                    #[allow(non_camel_case_types)]
                    struct GetEntitySvc<T: TaskHubSidecarService>(pub Arc<T>);
                    impl<
                        T: TaskHubSidecarService,
                    > tonic::server::UnaryService<super::GetEntityRequest>
                    for GetEntitySvc<T> {
                        type Response = super::GetEntityResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetEntityRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as TaskHubSidecarService>::get_entity(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetEntitySvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/TaskHubSidecarService/QueryEntities" => {
                    #[allow(non_camel_case_types)]
                    struct QueryEntitiesSvc<T: TaskHubSidecarService>(pub Arc<T>);
                    impl<
                        T: TaskHubSidecarService,
                    > tonic::server::UnaryService<super::QueryEntitiesRequest>
                    for QueryEntitiesSvc<T> {
                        type Response = super::QueryEntitiesResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::QueryEntitiesRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as TaskHubSidecarService>::query_entities(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = QueryEntitiesSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/TaskHubSidecarService/CleanEntityStorage" => {
                    #[allow(non_camel_case_types)]
                    struct CleanEntityStorageSvc<T: TaskHubSidecarService>(pub Arc<T>);
                    impl<
                        T: TaskHubSidecarService,
                    > tonic::server::UnaryService<super::CleanEntityStorageRequest>
                    for CleanEntityStorageSvc<T> {
                        type Response = super::CleanEntityStorageResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::CleanEntityStorageRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as TaskHubSidecarService>::clean_entity_storage(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = CleanEntityStorageSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                _ => {
                    Box::pin(async move {
                        let mut response = http::Response::new(empty_body());
                        let headers = response.headers_mut();
                        headers
                            .insert(
                                tonic::Status::GRPC_STATUS,
                                (tonic::Code::Unimplemented as i32).into(),
                            );
                        headers
                            .insert(
                                http::header::CONTENT_TYPE,
                                tonic::metadata::GRPC_CONTENT_TYPE,
                            );
                        Ok(response)
                    })
                }
            }
        }
    }
    impl<T> Clone for TaskHubSidecarServiceServer<T> {
        fn clone(&self) -> Self {
            let inner = self.inner.clone();
            Self {
                inner,
                accept_compression_encodings: self.accept_compression_encodings,
                send_compression_encodings: self.send_compression_encodings,
                max_decoding_message_size: self.max_decoding_message_size,
                max_encoding_message_size: self.max_encoding_message_size,
            }
        }
    }
    /// Generated gRPC service name
    pub const SERVICE_NAME: &str = "TaskHubSidecarService";
    impl<T> tonic::server::NamedService for TaskHubSidecarServiceServer<T> {
        const NAME: &'static str = SERVICE_NAME;
    }
}