ora_proto/generated/

ora.server.v1.rs

// This file is @generated by prost-build.
/// Request for `Heartbeat`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExecutorConnectionRequest {
    /// A message sent from the executor.
    #[prost(message, optional, tag = "1")]
    pub message: ::core::option::Option<ExecutorMessage>,
}
impl ::prost::Name for ExecutorConnectionRequest {
    const NAME: &'static str = "ExecutorConnectionRequest";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.ExecutorConnectionRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.ExecutorConnectionRequest".into()
    }
}
/// Response for `Heartbeat`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExecutorConnectionResponse {
    /// A message sent from the server.
    #[prost(message, optional, tag = "1")]
    pub message: ::core::option::Option<ServerMessage>,
}
impl ::prost::Name for ExecutorConnectionResponse {
    const NAME: &'static str = "ExecutorConnectionResponse";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.ExecutorConnectionResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.ExecutorConnectionResponse".into()
    }
}
/// A message sent from the executor.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExecutorMessage {
    /// The message.
    #[prost(
        oneof = "executor_message::ExecutorMessageKind",
        tags = "1, 2, 3, 4, 5"
    )]
    pub executor_message_kind: ::core::option::Option<executor_message::ExecutorMessageKind>,
}
/// Nested message and enum types in `ExecutorMessage`.
pub mod executor_message {
    /// The message.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum ExecutorMessageKind {
        /// The capabilities of the executor.
        ///
        /// The executor must send the capabilities
        /// as the first message in the stream
        /// before any heartbeats, subsequent capabilities
        /// messages might be ignored.
        #[prost(message, tag = "1")]
        Capabilities(super::ExecutorCapabilities),
        /// The heartbeat request.
        #[prost(message, tag = "2")]
        Heartbeat(super::ExecutorHeartbeat),
        /// The job execution has started.
        #[prost(message, tag = "3")]
        ExecutionStarted(super::ExecutionStarted),
        /// The execution has succeeded.
        #[prost(message, tag = "4")]
        ExecutionSucceeded(super::ExecutionSucceeded),
        /// The execution has failed.
        #[prost(message, tag = "5")]
        ExecutionFailed(super::ExecutionFailed),
    }
}
impl ::prost::Name for ExecutorMessage {
    const NAME: &'static str = "ExecutorMessage";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.ExecutorMessage".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.ExecutorMessage".into()
    }
}
/// Capabilities of the executor and other information
/// that the server needs to know about the executor.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExecutorCapabilities {
    /// The name of the executor.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The supported job types.
    #[prost(message, repeated, tag = "2")]
    pub supported_job_types: ::prost::alloc::vec::Vec<super::super::common::v1::JobType>,
    /// The maximum number of concurrent job executions.
    ///
    /// The server will not assign more than `max_concurrent_executions`
    /// job executions at the same time.
    ///
    /// 0 means no limit. Note that other than this currently
    /// there is no backpressure mechanism in place, a sensible
    /// limit is recommended in all cases.
    #[prost(uint32, tag = "3")]
    pub max_concurrent_executions: u32,
}
impl ::prost::Name for ExecutorCapabilities {
    const NAME: &'static str = "ExecutorCapabilities";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.ExecutorCapabilities".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.ExecutorCapabilities".into()
    }
}
/// The heartbeat content.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ExecutorHeartbeat {}
impl ::prost::Name for ExecutorHeartbeat {
    const NAME: &'static str = "ExecutorHeartbeat";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.ExecutorHeartbeat".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.ExecutorHeartbeat".into()
    }
}
/// The job execution has started.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExecutionStarted {
    /// The ID of the job execution.
    #[prost(string, tag = "1")]
    pub execution_id: ::prost::alloc::string::String,
    /// The time when the job execution started.
    #[prost(message, optional, tag = "2")]
    pub timestamp: ::core::option::Option<::prost_types::Timestamp>,
}
impl ::prost::Name for ExecutionStarted {
    const NAME: &'static str = "ExecutionStarted";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.ExecutionStarted".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.ExecutionStarted".into()
    }
}
/// A job execution has succeeded.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExecutionSucceeded {
    /// The ID of the job execution.
    #[prost(string, tag = "1")]
    pub execution_id: ::prost::alloc::string::String,
    /// The time when the job execution succeeded.
    #[prost(message, optional, tag = "2")]
    pub timestamp: ::core::option::Option<::prost_types::Timestamp>,
    /// The output payload of the job.
    #[prost(string, tag = "3")]
    pub output_payload_json: ::prost::alloc::string::String,
}
impl ::prost::Name for ExecutionSucceeded {
    const NAME: &'static str = "ExecutionSucceeded";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.ExecutionSucceeded".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.ExecutionSucceeded".into()
    }
}
/// The job execution has failed.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExecutionFailed {
    /// The ID of the job execution.
    #[prost(string, tag = "1")]
    pub execution_id: ::prost::alloc::string::String,
    /// The time when the job execution failed.
    #[prost(message, optional, tag = "2")]
    pub timestamp: ::core::option::Option<::prost_types::Timestamp>,
    /// The error message of the job.
    #[prost(string, tag = "3")]
    pub error_message: ::prost::alloc::string::String,
}
impl ::prost::Name for ExecutionFailed {
    const NAME: &'static str = "ExecutionFailed";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.ExecutionFailed".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.ExecutionFailed".into()
    }
}
/// A message sent from the server.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ServerMessage {
    /// The message.
    #[prost(oneof = "server_message::ServerMessageKind", tags = "1, 2, 3")]
    pub server_message_kind: ::core::option::Option<server_message::ServerMessageKind>,
}
/// Nested message and enum types in `ServerMessage`.
pub mod server_message {
    /// The message.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum ServerMessageKind {
        /// The properties of the executor.
        #[prost(message, tag = "1")]
        Properties(super::ExecutorProperties),
        /// A job execution is ready to be executed by the executor.
        #[prost(message, tag = "2")]
        ExecutionReady(super::ExecutionReady),
        /// The job execution was cancelled and should be dropped by the executor.
        #[prost(message, tag = "3")]
        ExecutionCancelled(super::ExecutionCancelled),
    }
}
impl ::prost::Name for ServerMessage {
    const NAME: &'static str = "ServerMessage";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.ServerMessage".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.ServerMessage".into()
    }
}
/// Properties of the executor assigned by the server.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExecutorProperties {
    /// The ID given to the executor.
    #[prost(string, tag = "1")]
    pub executor_id: ::prost::alloc::string::String,
    /// The maximum interval between heartbeats.
    ///
    /// Executors should repeat the executor ping
    /// request at least every `max_heartbeat_interval`.
    ///
    /// Note that delays in the network or the server
    /// may cause the executor to miss the deadline,
    /// so the executor should send the heartbeat
    /// before the deadline to account for this.
    #[prost(message, optional, tag = "2")]
    pub max_heartbeat_interval: ::core::option::Option<::prost_types::Duration>,
}
impl ::prost::Name for ExecutorProperties {
    const NAME: &'static str = "ExecutorProperties";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.ExecutorProperties".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.ExecutorProperties".into()
    }
}
/// A job execution is ready to be executed by the executor.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExecutionReady {
    /// The ID of the job.
    #[prost(string, tag = "1")]
    pub job_id: ::prost::alloc::string::String,
    /// The execution ID of the job.
    #[prost(string, tag = "2")]
    pub execution_id: ::prost::alloc::string::String,
    /// The job type ID.
    #[prost(string, tag = "3")]
    pub job_type_id: ::prost::alloc::string::String,
    /// The attempt number of the job execution.
    ///
    /// The first attempt is 1.
    #[prost(uint64, tag = "4")]
    pub attempt_number: u64,
    /// The input payload of the job.
    #[prost(string, tag = "5")]
    pub input_payload_json: ::prost::alloc::string::String,
    /// The target execution time of the job.
    #[prost(message, optional, tag = "6")]
    pub target_execution_time: ::core::option::Option<::prost_types::Timestamp>,
}
impl ::prost::Name for ExecutionReady {
    const NAME: &'static str = "ExecutionReady";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.ExecutionReady".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.ExecutionReady".into()
    }
}
/// The job execution was cancelled and should be dropped by the executor.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExecutionCancelled {
    /// The ID of the job execution.
    #[prost(string, tag = "1")]
    pub execution_id: ::prost::alloc::string::String,
}
impl ::prost::Name for ExecutionCancelled {
    const NAME: &'static str = "ExecutionCancelled";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.ExecutionCancelled".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.ExecutionCancelled".into()
    }
}
/// Generated client implementations.
pub mod executor_service_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value
    )]
    use tonic::codegen::http::Uri;
    use tonic::codegen::*;
    /// Endpoint on the server for a single executor.
    #[derive(Debug, Clone)]
    pub struct ExecutorServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ExecutorServiceClient<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> ExecutorServiceClient<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,
        ) -> ExecutorServiceClient<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,
        {
            ExecutorServiceClient::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
        }
        /// Long-lived bidirectional stream for the executor.
        pub async fn executor_connection(
            &mut self,
            request: impl tonic::IntoStreamingRequest<Message = super::ExecutorConnectionRequest>,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::ExecutorConnectionResponse>>,
            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(
                "/ora.server.v1.ExecutorService/ExecutorConnection",
            );
            let mut req = request.into_streaming_request();
            req.extensions_mut().insert(GrpcMethod::new(
                "ora.server.v1.ExecutorService",
                "ExecutorConnection",
            ));
            self.inner.streaming(req, path, codec).await
        }
    }
}
/// Generated server implementations.
pub mod executor_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 ExecutorServiceServer.
    #[async_trait]
    pub trait ExecutorService: std::marker::Send + std::marker::Sync + 'static {
        /// Long-lived bidirectional stream for the executor.
        async fn executor_connection(
            &self,
            request: tonic::Request<tonic::Streaming<super::ExecutorConnectionRequest>>,
        ) -> std::result::Result<
            tonic::Response<BoxStream<super::ExecutorConnectionResponse>>,
            tonic::Status,
        > {
            Err(tonic::Status::unimplemented("Not yet implemented"))
        }
    }
    /// Endpoint on the server for a single executor.
    #[derive(Debug)]
    pub struct ExecutorServiceServer<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> ExecutorServiceServer<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 ExecutorServiceServer<T>
    where
        T: ExecutorService,
        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() {
                "/ora.server.v1.ExecutorService/ExecutorConnection" => {
                    #[allow(non_camel_case_types)]
                    struct ExecutorConnectionSvc<T: ExecutorService>(pub Arc<T>);
                    impl<T: ExecutorService>
                        tonic::server::StreamingService<super::ExecutorConnectionRequest>
                        for ExecutorConnectionSvc<T>
                    {
                        type Response = super::ExecutorConnectionResponse;
                        type ResponseStream = BoxStream<super::ExecutorConnectionResponse>;
                        type Future =
                            BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<
                                tonic::Streaming<super::ExecutorConnectionRequest>,
                            >,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as ExecutorService>::executor_connection(&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 = ExecutorConnectionSvc(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.streaming(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 ExecutorServiceServer<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 = "ora.server.v1.ExecutorService";
    impl<T> tonic::server::NamedService for ExecutorServiceServer<T> {
        const NAME: &'static str = SERVICE_NAME;
    }
}
/// Request for `AddJobs`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AddJobsRequest {
    /// The jobs to add.
    #[prost(message, repeated, tag = "1")]
    pub jobs: ::prost::alloc::vec::Vec<super::super::common::v1::JobDefinition>,
}
impl ::prost::Name for AddJobsRequest {
    const NAME: &'static str = "AddJobsRequest";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.AddJobsRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.AddJobsRequest".into()
    }
}
/// Response for `AddJobs`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AddJobsResponse {
    /// The IDs of the added jobs.
    #[prost(string, repeated, tag = "1")]
    pub job_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
impl ::prost::Name for AddJobsResponse {
    const NAME: &'static str = "AddJobsResponse";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.AddJobsResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.AddJobsResponse".into()
    }
}
/// Request for `AddJobIfNotExists`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AddJobIfNotExistsRequest {
    /// The job to add.
    #[prost(message, optional, tag = "1")]
    pub job: ::core::option::Option<super::super::common::v1::JobDefinition>,
    /// The filter to select the job to return if it already exists.
    ///
    /// The filter is not tied to the job being added in any way.
    /// It is possible to select jobs with different job types
    /// or different labels.
    #[prost(message, optional, tag = "2")]
    pub filter: ::core::option::Option<JobQueryFilter>,
}
impl ::prost::Name for AddJobIfNotExistsRequest {
    const NAME: &'static str = "AddJobIfNotExistsRequest";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.AddJobIfNotExistsRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.AddJobIfNotExistsRequest".into()
    }
}
/// Response for `AddJobIfNotExists`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AddJobIfNotExistsResponse {
    /// The ID of the job either added or found.
    #[prost(string, tag = "1")]
    pub job_id: ::prost::alloc::string::String,
    /// Whether the job was added.
    #[prost(bool, tag = "2")]
    pub added: bool,
}
impl ::prost::Name for AddJobIfNotExistsResponse {
    const NAME: &'static str = "AddJobIfNotExistsResponse";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.AddJobIfNotExistsResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.AddJobIfNotExistsResponse".into()
    }
}
/// Request for `ListJobs`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListJobsRequest {
    /// A cursor that can be used to continue a previous query.
    ///
    /// Note that if the cursor is present, filters
    /// and order may be ignored.
    #[prost(string, optional, tag = "1")]
    pub cursor: ::core::option::Option<::prost::alloc::string::String>,
    /// Filter the returned jobs.
    #[prost(message, optional, tag = "2")]
    pub filter: ::core::option::Option<JobQueryFilter>,
    /// The order of the returned jobs.
    #[prost(enumeration = "JobQueryOrder", optional, tag = "3")]
    pub order: ::core::option::Option<i32>,
    /// The maximum number of jobs to return.
    ///
    /// If the number is 0, the amount
    /// returned is unspecified.
    #[prost(uint32, tag = "4")]
    pub limit: u32,
}
impl ::prost::Name for ListJobsRequest {
    const NAME: &'static str = "ListJobsRequest";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.ListJobsRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.ListJobsRequest".into()
    }
}
/// Response for `ListJobs`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListJobsResponse {
    /// A batch of jobs.
    #[prost(message, repeated, tag = "1")]
    pub jobs: ::prost::alloc::vec::Vec<Job>,
    /// A cursor that can be used to continue a previous query.
    ///
    /// A cursor may be present even if there are no more
    /// jobs to return.
    ///
    /// Note that the format of the cursor is implementation-specific
    /// and should not be relied upon.
    #[prost(string, optional, tag = "2")]
    pub cursor: ::core::option::Option<::prost::alloc::string::String>,
    /// Whether there are more jobs to return.
    #[prost(bool, tag = "3")]
    pub has_more: bool,
}
impl ::prost::Name for ListJobsResponse {
    const NAME: &'static str = "ListJobsResponse";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.ListJobsResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.ListJobsResponse".into()
    }
}
/// Request for `ListJobTypes`.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ListJobTypesRequest {}
impl ::prost::Name for ListJobTypesRequest {
    const NAME: &'static str = "ListJobTypesRequest";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.ListJobTypesRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.ListJobTypesRequest".into()
    }
}
/// Response for `ListJobTypes`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListJobTypesResponse {
    /// The job types.
    #[prost(message, repeated, tag = "1")]
    pub job_types: ::prost::alloc::vec::Vec<super::super::common::v1::JobType>,
}
impl ::prost::Name for ListJobTypesResponse {
    const NAME: &'static str = "ListJobTypesResponse";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.ListJobTypesResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.ListJobTypesResponse".into()
    }
}
/// Request for `CountJobs`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CountJobsRequest {
    /// Filter the jobs to count.
    #[prost(message, optional, tag = "1")]
    pub filter: ::core::option::Option<JobQueryFilter>,
}
impl ::prost::Name for CountJobsRequest {
    const NAME: &'static str = "CountJobsRequest";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.CountJobsRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.CountJobsRequest".into()
    }
}
/// Response for `CountJobs`.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct CountJobsResponse {
    /// The number of jobs.
    #[prost(uint64, tag = "1")]
    pub count: u64,
}
impl ::prost::Name for CountJobsResponse {
    const NAME: &'static str = "CountJobsResponse";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.CountJobsResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.CountJobsResponse".into()
    }
}
/// Request for `CancelJobs`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CancelJobsRequest {
    /// The filter to select the jobs to cancel.
    #[prost(message, optional, tag = "1")]
    pub filter: ::core::option::Option<JobQueryFilter>,
}
impl ::prost::Name for CancelJobsRequest {
    const NAME: &'static str = "CancelJobsRequest";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.CancelJobsRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.CancelJobsRequest".into()
    }
}
/// Response for `CancelJobs`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CancelJobsResponse {
    /// The IDs of the cancelled jobs.
    #[prost(string, repeated, tag = "1")]
    pub job_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
impl ::prost::Name for CancelJobsResponse {
    const NAME: &'static str = "CancelJobsResponse";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.CancelJobsResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.CancelJobsResponse".into()
    }
}
/// Request for `DeleteInactiveJobs`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteInactiveJobsRequest {
    /// The filter to select the jobs to remove.
    #[prost(message, optional, tag = "1")]
    pub filter: ::core::option::Option<JobQueryFilter>,
}
impl ::prost::Name for DeleteInactiveJobsRequest {
    const NAME: &'static str = "DeleteInactiveJobsRequest";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.DeleteInactiveJobsRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.DeleteInactiveJobsRequest".into()
    }
}
/// Response for `DeleteInactiveJobs`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteInactiveJobsResponse {
    /// The IDs of the cleaned up jobs.
    #[prost(string, repeated, tag = "1")]
    pub job_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
impl ::prost::Name for DeleteInactiveJobsResponse {
    const NAME: &'static str = "DeleteInactiveJobsResponse";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.DeleteInactiveJobsResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.DeleteInactiveJobsResponse".into()
    }
}
/// Request for `ListExecutors`.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct ListExecutorsRequest {}
impl ::prost::Name for ListExecutorsRequest {
    const NAME: &'static str = "ListExecutorsRequest";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.ListExecutorsRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.ListExecutorsRequest".into()
    }
}
/// Response for `ListExecutors`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListExecutorsResponse {
    /// The executors.
    #[prost(message, repeated, tag = "1")]
    pub executors: ::prost::alloc::vec::Vec<ExecutorInfo>,
}
impl ::prost::Name for ListExecutorsResponse {
    const NAME: &'static str = "ListExecutorsResponse";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.ListExecutorsResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.ListExecutorsResponse".into()
    }
}
/// Request for `CreateSchedules`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateSchedulesRequest {
    /// The schedules to create.
    #[prost(message, repeated, tag = "1")]
    pub schedules: ::prost::alloc::vec::Vec<super::super::common::v1::ScheduleDefinition>,
}
impl ::prost::Name for CreateSchedulesRequest {
    const NAME: &'static str = "CreateSchedulesRequest";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.CreateSchedulesRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.CreateSchedulesRequest".into()
    }
}
/// Response for `CreateSchedules`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateSchedulesResponse {
    /// The IDs of the created schedules.
    #[prost(string, repeated, tag = "1")]
    pub schedule_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
impl ::prost::Name for CreateSchedulesResponse {
    const NAME: &'static str = "CreateSchedulesResponse";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.CreateSchedulesResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.CreateSchedulesResponse".into()
    }
}
/// Request for `AddSchedules`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AddSchedulesRequest {
    /// The schedules to add.
    #[prost(message, repeated, tag = "1")]
    pub schedules: ::prost::alloc::vec::Vec<super::super::common::v1::ScheduleDefinition>,
}
impl ::prost::Name for AddSchedulesRequest {
    const NAME: &'static str = "AddSchedulesRequest";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.AddSchedulesRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.AddSchedulesRequest".into()
    }
}
/// Response for `AddSchedules`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AddSchedulesResponse {
    /// The IDs of the added schedules.
    #[prost(string, repeated, tag = "1")]
    pub schedule_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
impl ::prost::Name for AddSchedulesResponse {
    const NAME: &'static str = "AddSchedulesResponse";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.AddSchedulesResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.AddSchedulesResponse".into()
    }
}
/// Request for `AddScheduleIfNotExists`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AddScheduleIfNotExistsRequest {
    /// The schedule to add.
    #[prost(message, optional, tag = "1")]
    pub schedule: ::core::option::Option<super::super::common::v1::ScheduleDefinition>,
    /// The filter to select the schedule to return if it already exists.
    ///
    /// The filter is not tied to the schedule being added in any way.
    /// It is possible to select schedules with different job types
    /// or different labels.
    #[prost(message, optional, tag = "2")]
    pub filter: ::core::option::Option<ScheduleQueryFilter>,
}
impl ::prost::Name for AddScheduleIfNotExistsRequest {
    const NAME: &'static str = "AddScheduleIfNotExistsRequest";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.AddScheduleIfNotExistsRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.AddScheduleIfNotExistsRequest".into()
    }
}
/// Response for `AddScheduleIfNotExists`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AddScheduleIfNotExistsResponse {
    /// The ID of the schedule either added or found.
    #[prost(string, tag = "1")]
    pub schedule_id: ::prost::alloc::string::String,
    /// Whether the schedule was added.
    #[prost(bool, tag = "2")]
    pub added: bool,
}
impl ::prost::Name for AddScheduleIfNotExistsResponse {
    const NAME: &'static str = "AddScheduleIfNotExistsResponse";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.AddScheduleIfNotExistsResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.AddScheduleIfNotExistsResponse".into()
    }
}
/// Request for `ListSchedules`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSchedulesRequest {
    /// A cursor that can be used to continue a previous query.
    ///
    /// Note that if the cursor is present, filters
    /// and order may be ignored.
    #[prost(string, optional, tag = "1")]
    pub cursor: ::core::option::Option<::prost::alloc::string::String>,
    /// Filter the returned schedules.
    #[prost(message, optional, tag = "2")]
    pub filter: ::core::option::Option<ScheduleQueryFilter>,
    /// The order of the returned schedules.
    #[prost(enumeration = "ScheduleQueryOrder", optional, tag = "3")]
    pub order: ::core::option::Option<i32>,
    /// The maximum number of schedules to return.
    ///
    /// If the number is 0, the amount
    /// returned is unspecified.
    #[prost(uint32, tag = "4")]
    pub limit: u32,
}
impl ::prost::Name for ListSchedulesRequest {
    const NAME: &'static str = "ListSchedulesRequest";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.ListSchedulesRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.ListSchedulesRequest".into()
    }
}
/// Response for `ListSchedules`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSchedulesResponse {
    /// A batch of schedules.
    #[prost(message, repeated, tag = "1")]
    pub schedules: ::prost::alloc::vec::Vec<Schedule>,
    /// A cursor that can be used to continue a previous query.
    ///
    /// A cursor may be present even if there are no more
    /// schedules to return.
    ///
    /// Note that the format of the cursor is implementation-specific
    /// and should not be relied upon.
    #[prost(string, optional, tag = "2")]
    pub cursor: ::core::option::Option<::prost::alloc::string::String>,
    /// Whether there are more schedules to return.
    #[prost(bool, tag = "3")]
    pub has_more: bool,
}
impl ::prost::Name for ListSchedulesResponse {
    const NAME: &'static str = "ListSchedulesResponse";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.ListSchedulesResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.ListSchedulesResponse".into()
    }
}
/// Request for `CountSchedules`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CountSchedulesRequest {
    /// Filter the schedules to count.
    #[prost(message, optional, tag = "1")]
    pub filter: ::core::option::Option<ScheduleQueryFilter>,
}
impl ::prost::Name for CountSchedulesRequest {
    const NAME: &'static str = "CountSchedulesRequest";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.CountSchedulesRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.CountSchedulesRequest".into()
    }
}
/// Response for `CountSchedules`.
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct CountSchedulesResponse {
    /// The number of schedules.
    #[prost(uint64, tag = "1")]
    pub count: u64,
}
impl ::prost::Name for CountSchedulesResponse {
    const NAME: &'static str = "CountSchedulesResponse";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.CountSchedulesResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.CountSchedulesResponse".into()
    }
}
/// Request for `CancelSchedules`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CancelSchedulesRequest {
    /// The filter to select the schedules to cancel.
    #[prost(message, optional, tag = "1")]
    pub filter: ::core::option::Option<ScheduleQueryFilter>,
    /// Whether to also cancel the jobs created by the schedules.
    #[prost(bool, tag = "2")]
    pub cancel_jobs: bool,
}
impl ::prost::Name for CancelSchedulesRequest {
    const NAME: &'static str = "CancelSchedulesRequest";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.CancelSchedulesRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.CancelSchedulesRequest".into()
    }
}
/// Response for `CancelSchedules`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CancelSchedulesResponse {
    /// The IDs of the cancelled schedules.
    #[prost(string, repeated, tag = "1")]
    pub schedule_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// The IDs of the cancelled jobs that were
    /// created by the schedules.
    #[prost(string, repeated, tag = "2")]
    pub job_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
impl ::prost::Name for CancelSchedulesResponse {
    const NAME: &'static str = "CancelSchedulesResponse";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.CancelSchedulesResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.CancelSchedulesResponse".into()
    }
}
/// Request for `DeleteInactiveSchedules`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteInactiveSchedulesRequest {
    /// The filter to select the schedules to remove.
    #[prost(message, optional, tag = "1")]
    pub filter: ::core::option::Option<ScheduleQueryFilter>,
}
impl ::prost::Name for DeleteInactiveSchedulesRequest {
    const NAME: &'static str = "DeleteInactiveSchedulesRequest";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.DeleteInactiveSchedulesRequest".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.DeleteInactiveSchedulesRequest".into()
    }
}
/// Response for `DeleteInactiveSchedules`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteInactiveSchedulesResponse {
    /// The IDs of the cleaned up schedules.
    #[prost(string, repeated, tag = "1")]
    pub schedule_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
impl ::prost::Name for DeleteInactiveSchedulesResponse {
    const NAME: &'static str = "DeleteInactiveSchedulesResponse";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.DeleteInactiveSchedulesResponse".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.DeleteInactiveSchedulesResponse".into()
    }
}
/// Filter of job queries.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct JobQueryFilter {
    /// The job IDs to filter by.
    ///
    /// If the list is empty, all jobs are included.
    #[prost(string, repeated, tag = "1")]
    pub job_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// The job type IDs to filter by.
    ///
    /// If the list is empty, all job types are included.
    #[prost(string, repeated, tag = "2")]
    pub job_type_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// The execution IDs to filter by.
    ///
    /// If the list is empty, all executors are included.
    #[prost(string, repeated, tag = "3")]
    pub execution_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// The schedule IDs to filter by.
    ///
    /// If the list is empty, all schedules and jobs without
    /// schedules are included.
    #[prost(string, repeated, tag = "4")]
    pub schedule_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// A list of execution statuses to filter by.
    /// If the list is empty, all statuses are included.
    ///
    /// If a job has multiple executions, the last
    /// execution status is used.
    ///
    /// If a job has no executions, its status is
    /// considered to be pending.
    #[prost(enumeration = "JobExecutionStatus", repeated, tag = "5")]
    pub status: ::prost::alloc::vec::Vec<i32>,
    /// A list of labels to filter by.
    ///
    /// If multiple filters are specified, all of them
    /// must match.
    #[prost(message, repeated, tag = "6")]
    pub labels: ::prost::alloc::vec::Vec<JobLabelFilter>,
    /// Only include active or inactive jobs.
    ///
    /// If not provided, all jobs are included.
    #[prost(bool, optional, tag = "7")]
    pub active: ::core::option::Option<bool>,
    /// Filter by the target execution time.
    ///
    /// The range can be open-ended in either direction.
    #[prost(message, optional, tag = "8")]
    pub target_execution_time: ::core::option::Option<super::super::common::v1::TimeRange>,
    /// Filter by the time the job was created.
    ///
    /// The range can be open-ended in either direction.
    #[prost(message, optional, tag = "9")]
    pub created_at: ::core::option::Option<super::super::common::v1::TimeRange>,
}
impl ::prost::Name for JobQueryFilter {
    const NAME: &'static str = "JobQueryFilter";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.JobQueryFilter".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.JobQueryFilter".into()
    }
}
/// A job label filter.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct JobLabelFilter {
    /// The key of the label.
    #[prost(string, tag = "1")]
    pub key: ::prost::alloc::string::String,
    /// The condition of matching the value.
    #[prost(oneof = "job_label_filter::Value", tags = "2, 3")]
    pub value: ::core::option::Option<job_label_filter::Value>,
}
/// Nested message and enum types in `JobLabelFilter`.
pub mod job_label_filter {
    /// The condition of matching the value.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Value {
        /// Whether the label should exist with any value.
        #[prost(enumeration = "super::LabelFilterExistCondition", tag = "2")]
        Exists(i32),
        /// The value must be equal to the given value.
        #[prost(string, tag = "3")]
        Equals(::prost::alloc::string::String),
    }
}
impl ::prost::Name for JobLabelFilter {
    const NAME: &'static str = "JobLabelFilter";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.JobLabelFilter".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.JobLabelFilter".into()
    }
}
/// A job.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Job {
    /// The ID of the job.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// The ID of the schedule that created the job.
    #[prost(string, optional, tag = "2")]
    pub schedule_id: ::core::option::Option<::prost::alloc::string::String>,
    /// The job definition.
    #[prost(message, optional, tag = "3")]
    pub definition: ::core::option::Option<super::super::common::v1::JobDefinition>,
    /// The time the job was created.
    #[prost(message, optional, tag = "4")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// All the executions of this job.
    #[prost(message, repeated, tag = "5")]
    pub executions: ::prost::alloc::vec::Vec<JobExecution>,
    /// Whether the job is active.
    #[prost(bool, tag = "6")]
    pub active: bool,
    /// Whether the job was cancelled.
    #[prost(bool, tag = "7")]
    pub cancelled: bool,
}
impl ::prost::Name for Job {
    const NAME: &'static str = "Job";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.Job".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.Job".into()
    }
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct JobExecution {
    /// The ID of the job execution.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// The ID of the job.
    #[prost(string, tag = "2")]
    pub job_id: ::prost::alloc::string::String,
    /// The ID of the associated executor.
    #[prost(string, optional, tag = "3")]
    pub executor_id: ::core::option::Option<::prost::alloc::string::String>,
    /// The status of the job execution.
    #[prost(enumeration = "JobExecutionStatus", tag = "4")]
    pub status: i32,
    /// The time the job execution was created.
    #[prost(message, optional, tag = "5")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// The time the job execution was marked as ready.
    #[prost(message, optional, tag = "6")]
    pub ready_at: ::core::option::Option<::prost_types::Timestamp>,
    /// The time the job execution was assigned to an executor.
    #[prost(message, optional, tag = "7")]
    pub assigned_at: ::core::option::Option<::prost_types::Timestamp>,
    /// The time the job execution has started.
    #[prost(message, optional, tag = "8")]
    pub started_at: ::core::option::Option<::prost_types::Timestamp>,
    /// The time the job execution has succeeded.
    #[prost(message, optional, tag = "9")]
    pub succeeded_at: ::core::option::Option<::prost_types::Timestamp>,
    /// The time the job execution has failed.
    #[prost(message, optional, tag = "10")]
    pub failed_at: ::core::option::Option<::prost_types::Timestamp>,
    /// The output payload of the execution.
    #[prost(string, optional, tag = "11")]
    pub output_payload_json: ::core::option::Option<::prost::alloc::string::String>,
    /// The error message of the execution.
    #[prost(string, optional, tag = "12")]
    pub failure_reason: ::core::option::Option<::prost::alloc::string::String>,
}
impl ::prost::Name for JobExecution {
    const NAME: &'static str = "JobExecution";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.JobExecution".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.JobExecution".into()
    }
}
/// Information about an executor.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExecutorInfo {
    /// The ID of the executor.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// The name of the executor.
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    /// The time the executor was last seen.
    #[prost(message, optional, tag = "3")]
    pub last_seen_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Whether the executor is alive.
    #[prost(bool, tag = "4")]
    pub alive: bool,
    /// The job types supported by the executor.
    #[prost(string, repeated, tag = "5")]
    pub supported_job_type_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// The maximum number of concurrent job executions.
    #[prost(uint32, tag = "6")]
    pub max_concurrent_executions: u32,
    /// A list of execution IDs assigned to the executor.
    #[prost(string, repeated, tag = "7")]
    pub assigned_execution_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
impl ::prost::Name for ExecutorInfo {
    const NAME: &'static str = "ExecutorInfo";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.ExecutorInfo".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.ExecutorInfo".into()
    }
}
/// A schedule.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Schedule {
    /// The ID of the schedule.
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    /// The schedule definition.
    #[prost(message, optional, tag = "2")]
    pub definition: ::core::option::Option<super::super::common::v1::ScheduleDefinition>,
    /// The time the schedule was created.
    #[prost(message, optional, tag = "3")]
    pub created_at: ::core::option::Option<::prost_types::Timestamp>,
    /// Whether the schedule is active.
    #[prost(bool, tag = "5")]
    pub active: bool,
    /// Whether the schedule was cancelled.
    #[prost(bool, tag = "6")]
    pub cancelled: bool,
}
impl ::prost::Name for Schedule {
    const NAME: &'static str = "Schedule";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.Schedule".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.Schedule".into()
    }
}
/// Filter of schedule queries.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ScheduleQueryFilter {
    /// The schedule IDs to filter by.
    ///
    /// If the list is empty, all schedules are included.
    #[prost(string, repeated, tag = "1")]
    pub schedule_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Filter by job IDs that
    /// are created by the schedules.
    ///
    /// If the list is empty, no filtering is done.
    #[prost(string, repeated, tag = "2")]
    pub job_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Filter by job type IDs of jobs
    /// that are created by the schedules (if applicable).
    ///
    /// If the list is empty, no filtering is done.
    #[prost(string, repeated, tag = "3")]
    pub job_type_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// A list of labels to filter by.
    ///
    /// If multiple filters are specified, all of them
    /// must match.
    #[prost(message, repeated, tag = "4")]
    pub labels: ::prost::alloc::vec::Vec<ScheduleLabelFilter>,
    /// Only include active or inactive schedules.
    ///
    /// If not provided, all schedules are included.
    #[prost(bool, optional, tag = "5")]
    pub active: ::core::option::Option<bool>,
    /// Filter by the time the schedule was created.
    ///
    /// The range can be open-ended in either direction.
    #[prost(message, optional, tag = "6")]
    pub created_at: ::core::option::Option<super::super::common::v1::TimeRange>,
}
impl ::prost::Name for ScheduleQueryFilter {
    const NAME: &'static str = "ScheduleQueryFilter";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.ScheduleQueryFilter".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.ScheduleQueryFilter".into()
    }
}
/// A schedule label filter.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ScheduleLabelFilter {
    /// The key of the label.
    #[prost(string, tag = "1")]
    pub key: ::prost::alloc::string::String,
    /// The condition of matching the value.
    #[prost(oneof = "schedule_label_filter::Value", tags = "2, 3")]
    pub value: ::core::option::Option<schedule_label_filter::Value>,
}
/// Nested message and enum types in `ScheduleLabelFilter`.
pub mod schedule_label_filter {
    /// The condition of matching the value.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Value {
        /// Whether the label should exist with any value.
        #[prost(enumeration = "super::LabelFilterExistCondition", tag = "2")]
        Exists(i32),
        /// The value must be equal to the given value.
        #[prost(string, tag = "3")]
        Equals(::prost::alloc::string::String),
    }
}
impl ::prost::Name for ScheduleLabelFilter {
    const NAME: &'static str = "ScheduleLabelFilter";
    const PACKAGE: &'static str = "ora.server.v1";
    fn full_name() -> ::prost::alloc::string::String {
        "ora.server.v1.ScheduleLabelFilter".into()
    }
    fn type_url() -> ::prost::alloc::string::String {
        "/ora.server.v1.ScheduleLabelFilter".into()
    }
}
/// The order of jobs returned.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum JobQueryOrder {
    /// The order is unspecified.
    Unspecified = 0,
    /// Order by the time the job was created in ascending order.
    CreatedAtAsc = 1,
    /// Order by the time the job was created in descending order.
    CreatedAtDesc = 2,
    /// Order by the target execution time in ascending order.
    TargetExecutionTimeAsc = 3,
    /// Order by the target execution time in descending order.
    TargetExecutionTimeDesc = 4,
}
impl JobQueryOrder {
    /// 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::Unspecified => "JOB_QUERY_ORDER_UNSPECIFIED",
            Self::CreatedAtAsc => "JOB_QUERY_ORDER_CREATED_AT_ASC",
            Self::CreatedAtDesc => "JOB_QUERY_ORDER_CREATED_AT_DESC",
            Self::TargetExecutionTimeAsc => "JOB_QUERY_ORDER_TARGET_EXECUTION_TIME_ASC",
            Self::TargetExecutionTimeDesc => "JOB_QUERY_ORDER_TARGET_EXECUTION_TIME_DESC",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "JOB_QUERY_ORDER_UNSPECIFIED" => Some(Self::Unspecified),
            "JOB_QUERY_ORDER_CREATED_AT_ASC" => Some(Self::CreatedAtAsc),
            "JOB_QUERY_ORDER_CREATED_AT_DESC" => Some(Self::CreatedAtDesc),
            "JOB_QUERY_ORDER_TARGET_EXECUTION_TIME_ASC" => Some(Self::TargetExecutionTimeAsc),
            "JOB_QUERY_ORDER_TARGET_EXECUTION_TIME_DESC" => Some(Self::TargetExecutionTimeDesc),
            _ => None,
        }
    }
}
/// The status of a job execution.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum JobExecutionStatus {
    /// The status is unspecified and depends on the implementation.
    Unspecified = 0,
    /// The job execution is pending and is not ready to run.
    Pending = 1,
    /// The job execution is ready to run.
    Ready = 2,
    /// The job execution was assigned to an executor.
    Assigned = 3,
    /// The job execution is running.
    Running = 4,
    /// The job execution is completed successfully.
    Succeeded = 5,
    /// The job execution is failed.
    Failed = 6,
}
impl JobExecutionStatus {
    /// 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::Unspecified => "JOB_EXECUTION_STATUS_UNSPECIFIED",
            Self::Pending => "JOB_EXECUTION_STATUS_PENDING",
            Self::Ready => "JOB_EXECUTION_STATUS_READY",
            Self::Assigned => "JOB_EXECUTION_STATUS_ASSIGNED",
            Self::Running => "JOB_EXECUTION_STATUS_RUNNING",
            Self::Succeeded => "JOB_EXECUTION_STATUS_SUCCEEDED",
            Self::Failed => "JOB_EXECUTION_STATUS_FAILED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "JOB_EXECUTION_STATUS_UNSPECIFIED" => Some(Self::Unspecified),
            "JOB_EXECUTION_STATUS_PENDING" => Some(Self::Pending),
            "JOB_EXECUTION_STATUS_READY" => Some(Self::Ready),
            "JOB_EXECUTION_STATUS_ASSIGNED" => Some(Self::Assigned),
            "JOB_EXECUTION_STATUS_RUNNING" => Some(Self::Running),
            "JOB_EXECUTION_STATUS_SUCCEEDED" => Some(Self::Succeeded),
            "JOB_EXECUTION_STATUS_FAILED" => Some(Self::Failed),
            _ => None,
        }
    }
}
/// The order of schedules returned.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ScheduleQueryOrder {
    /// The order is unspecified.
    Unspecified = 0,
    /// Order by the time the schedule was created in ascending order.
    CreatedAtAsc = 1,
    /// Order by the time the schedule was created in descending order.
    CreatedAtDesc = 2,
}
impl ScheduleQueryOrder {
    /// 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::Unspecified => "SCHEDULE_QUERY_ORDER_UNSPECIFIED",
            Self::CreatedAtAsc => "SCHEDULE_QUERY_ORDER_CREATED_AT_ASC",
            Self::CreatedAtDesc => "SCHEDULE_QUERY_ORDER_CREATED_AT_DESC",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SCHEDULE_QUERY_ORDER_UNSPECIFIED" => Some(Self::Unspecified),
            "SCHEDULE_QUERY_ORDER_CREATED_AT_ASC" => Some(Self::CreatedAtAsc),
            "SCHEDULE_QUERY_ORDER_CREATED_AT_DESC" => Some(Self::CreatedAtDesc),
            _ => None,
        }
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum LabelFilterExistCondition {
    /// The condition is unspecified.
    Unspecified = 0,
    /// The label must exist.
    Exists = 1,
}
impl LabelFilterExistCondition {
    /// 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::Unspecified => "LABEL_FILTER_EXIST_CONDITION_UNSPECIFIED",
            Self::Exists => "LABEL_FILTER_EXIST_CONDITION_EXISTS",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "LABEL_FILTER_EXIST_CONDITION_UNSPECIFIED" => Some(Self::Unspecified),
            "LABEL_FILTER_EXIST_CONDITION_EXISTS" => Some(Self::Exists),
            _ => None,
        }
    }
}
/// Generated client implementations.
pub mod admin_service_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value
    )]
    use tonic::codegen::http::Uri;
    use tonic::codegen::*;
    /// A service that provides administrative functionality.
    #[derive(Debug, Clone)]
    pub struct AdminServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl AdminServiceClient<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> AdminServiceClient<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,
        ) -> AdminServiceClient<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,
        {
            AdminServiceClient::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
        }
        /// Add jobs to be executed.
        pub async fn add_jobs(
            &mut self,
            request: impl tonic::IntoRequest<super::AddJobsRequest>,
        ) -> std::result::Result<tonic::Response<super::AddJobsResponse>, 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("/ora.server.v1.AdminService/AddJobs");
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("ora.server.v1.AdminService", "AddJobs"));
            self.inner.unary(req, path, codec).await
        }
        /// Add a job or return the first job that matches the given filter.
        ///
        /// This is semantically equivalent to sending a `CountJobs` request
        /// and adding the job if the count is 0.
        /// The difference is that this method is atomic thus it is
        /// not possible for another client to add the same job
        /// between the `CountJobs` and `AddJobs` calls.
        pub async fn add_job_if_not_exists(
            &mut self,
            request: impl tonic::IntoRequest<super::AddJobIfNotExistsRequest>,
        ) -> std::result::Result<tonic::Response<super::AddJobIfNotExistsResponse>, 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(
                "/ora.server.v1.AdminService/AddJobIfNotExists",
            );
            let mut req = request.into_request();
            req.extensions_mut().insert(GrpcMethod::new(
                "ora.server.v1.AdminService",
                "AddJobIfNotExists",
            ));
            self.inner.unary(req, path, codec).await
        }
        /// List jobs.
        pub async fn list_jobs(
            &mut self,
            request: impl tonic::IntoRequest<super::ListJobsRequest>,
        ) -> std::result::Result<tonic::Response<super::ListJobsResponse>, 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("/ora.server.v1.AdminService/ListJobs");
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("ora.server.v1.AdminService", "ListJobs"));
            self.inner.unary(req, path, codec).await
        }
        /// Count the number of jobs.
        pub async fn count_jobs(
            &mut self,
            request: impl tonic::IntoRequest<super::CountJobsRequest>,
        ) -> std::result::Result<tonic::Response<super::CountJobsResponse>, 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("/ora.server.v1.AdminService/CountJobs");
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("ora.server.v1.AdminService", "CountJobs"));
            self.inner.unary(req, path, codec).await
        }
        /// List all job types.
        pub async fn list_job_types(
            &mut self,
            request: impl tonic::IntoRequest<super::ListJobTypesRequest>,
        ) -> std::result::Result<tonic::Response<super::ListJobTypesResponse>, 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("/ora.server.v1.AdminService/ListJobTypes");
            let mut req = request.into_request();
            req.extensions_mut().insert(GrpcMethod::new(
                "ora.server.v1.AdminService",
                "ListJobTypes",
            ));
            self.inner.unary(req, path, codec).await
        }
        /// Cancel jobs.
        pub async fn cancel_jobs(
            &mut self,
            request: impl tonic::IntoRequest<super::CancelJobsRequest>,
        ) -> std::result::Result<tonic::Response<super::CancelJobsResponse>, 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("/ora.server.v1.AdminService/CancelJobs");
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("ora.server.v1.AdminService", "CancelJobs"));
            self.inner.unary(req, path, codec).await
        }
        /// Delete inactive jobs from storage.
        pub async fn delete_inactive_jobs(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteInactiveJobsRequest>,
        ) -> std::result::Result<tonic::Response<super::DeleteInactiveJobsResponse>, 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(
                "/ora.server.v1.AdminService/DeleteInactiveJobs",
            );
            let mut req = request.into_request();
            req.extensions_mut().insert(GrpcMethod::new(
                "ora.server.v1.AdminService",
                "DeleteInactiveJobs",
            ));
            self.inner.unary(req, path, codec).await
        }
        /// Get information about the executors.
        pub async fn list_executors(
            &mut self,
            request: impl tonic::IntoRequest<super::ListExecutorsRequest>,
        ) -> std::result::Result<tonic::Response<super::ListExecutorsResponse>, 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("/ora.server.v1.AdminService/ListExecutors");
            let mut req = request.into_request();
            req.extensions_mut().insert(GrpcMethod::new(
                "ora.server.v1.AdminService",
                "ListExecutors",
            ));
            self.inner.unary(req, path, codec).await
        }
        /// Create schedules.
        ///
        /// Deprecated: use `AddSchedules` instead.
        #[deprecated]
        pub async fn create_schedules(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateSchedulesRequest>,
        ) -> std::result::Result<tonic::Response<super::CreateSchedulesResponse>, 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("/ora.server.v1.AdminService/CreateSchedules");
            let mut req = request.into_request();
            req.extensions_mut().insert(GrpcMethod::new(
                "ora.server.v1.AdminService",
                "CreateSchedules",
            ));
            self.inner.unary(req, path, codec).await
        }
        /// Add schedules.
        pub async fn add_schedules(
            &mut self,
            request: impl tonic::IntoRequest<super::AddSchedulesRequest>,
        ) -> std::result::Result<tonic::Response<super::AddSchedulesResponse>, 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("/ora.server.v1.AdminService/AddSchedules");
            let mut req = request.into_request();
            req.extensions_mut().insert(GrpcMethod::new(
                "ora.server.v1.AdminService",
                "AddSchedules",
            ));
            self.inner.unary(req, path, codec).await
        }
        /// Add a schedule or return the first schedule that matches the given filter.
        ///
        /// This is semantically equivalent to sending a `CountSchedules` request
        /// and adding the schedule if the count is 0.
        /// The difference is that this method is atomic thus it is
        /// not possible for another client to add the same schedule
        /// between the `CountSchedules` and `CreateSchedules` calls.
        pub async fn add_schedule_if_not_exists(
            &mut self,
            request: impl tonic::IntoRequest<super::AddScheduleIfNotExistsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::AddScheduleIfNotExistsResponse>,
            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(
                "/ora.server.v1.AdminService/AddScheduleIfNotExists",
            );
            let mut req = request.into_request();
            req.extensions_mut().insert(GrpcMethod::new(
                "ora.server.v1.AdminService",
                "AddScheduleIfNotExists",
            ));
            self.inner.unary(req, path, codec).await
        }
        /// List schedules.
        pub async fn list_schedules(
            &mut self,
            request: impl tonic::IntoRequest<super::ListSchedulesRequest>,
        ) -> std::result::Result<tonic::Response<super::ListSchedulesResponse>, 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("/ora.server.v1.AdminService/ListSchedules");
            let mut req = request.into_request();
            req.extensions_mut().insert(GrpcMethod::new(
                "ora.server.v1.AdminService",
                "ListSchedules",
            ));
            self.inner.unary(req, path, codec).await
        }
        /// Count the number of schedules.
        pub async fn count_schedules(
            &mut self,
            request: impl tonic::IntoRequest<super::CountSchedulesRequest>,
        ) -> std::result::Result<tonic::Response<super::CountSchedulesResponse>, 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("/ora.server.v1.AdminService/CountSchedules");
            let mut req = request.into_request();
            req.extensions_mut().insert(GrpcMethod::new(
                "ora.server.v1.AdminService",
                "CountSchedules",
            ));
            self.inner.unary(req, path, codec).await
        }
        /// Cancel schedules.
        pub async fn cancel_schedules(
            &mut self,
            request: impl tonic::IntoRequest<super::CancelSchedulesRequest>,
        ) -> std::result::Result<tonic::Response<super::CancelSchedulesResponse>, 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("/ora.server.v1.AdminService/CancelSchedules");
            let mut req = request.into_request();
            req.extensions_mut().insert(GrpcMethod::new(
                "ora.server.v1.AdminService",
                "CancelSchedules",
            ));
            self.inner.unary(req, path, codec).await
        }
        /// Delete inactive schedules from storage.
        pub async fn delete_inactive_schedules(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteInactiveSchedulesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::DeleteInactiveSchedulesResponse>,
            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(
                "/ora.server.v1.AdminService/DeleteInactiveSchedules",
            );
            let mut req = request.into_request();
            req.extensions_mut().insert(GrpcMethod::new(
                "ora.server.v1.AdminService",
                "DeleteInactiveSchedules",
            ));
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Generated server implementations.
pub mod admin_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 AdminServiceServer.
    #[async_trait]
    pub trait AdminService: std::marker::Send + std::marker::Sync + 'static {
        /// Add jobs to be executed.
        async fn add_jobs(
            &self,
            request: tonic::Request<super::AddJobsRequest>,
        ) -> std::result::Result<tonic::Response<super::AddJobsResponse>, tonic::Status> {
            Err(tonic::Status::unimplemented("Not yet implemented"))
        }
        /// Add a job or return the first job that matches the given filter.
        ///
        /// This is semantically equivalent to sending a `CountJobs` request
        /// and adding the job if the count is 0.
        /// The difference is that this method is atomic thus it is
        /// not possible for another client to add the same job
        /// between the `CountJobs` and `AddJobs` calls.
        async fn add_job_if_not_exists(
            &self,
            request: tonic::Request<super::AddJobIfNotExistsRequest>,
        ) -> std::result::Result<tonic::Response<super::AddJobIfNotExistsResponse>, tonic::Status>
        {
            Err(tonic::Status::unimplemented("Not yet implemented"))
        }
        /// List jobs.
        async fn list_jobs(
            &self,
            request: tonic::Request<super::ListJobsRequest>,
        ) -> std::result::Result<tonic::Response<super::ListJobsResponse>, tonic::Status> {
            Err(tonic::Status::unimplemented("Not yet implemented"))
        }
        /// Count the number of jobs.
        async fn count_jobs(
            &self,
            request: tonic::Request<super::CountJobsRequest>,
        ) -> std::result::Result<tonic::Response<super::CountJobsResponse>, tonic::Status> {
            Err(tonic::Status::unimplemented("Not yet implemented"))
        }
        /// List all job types.
        async fn list_job_types(
            &self,
            request: tonic::Request<super::ListJobTypesRequest>,
        ) -> std::result::Result<tonic::Response<super::ListJobTypesResponse>, tonic::Status>
        {
            Err(tonic::Status::unimplemented("Not yet implemented"))
        }
        /// Cancel jobs.
        async fn cancel_jobs(
            &self,
            request: tonic::Request<super::CancelJobsRequest>,
        ) -> std::result::Result<tonic::Response<super::CancelJobsResponse>, tonic::Status>
        {
            Err(tonic::Status::unimplemented("Not yet implemented"))
        }
        /// Delete inactive jobs from storage.
        async fn delete_inactive_jobs(
            &self,
            request: tonic::Request<super::DeleteInactiveJobsRequest>,
        ) -> std::result::Result<tonic::Response<super::DeleteInactiveJobsResponse>, tonic::Status>
        {
            Err(tonic::Status::unimplemented("Not yet implemented"))
        }
        /// Get information about the executors.
        async fn list_executors(
            &self,
            request: tonic::Request<super::ListExecutorsRequest>,
        ) -> std::result::Result<tonic::Response<super::ListExecutorsResponse>, tonic::Status>
        {
            Err(tonic::Status::unimplemented("Not yet implemented"))
        }
        /// Create schedules.
        ///
        /// Deprecated: use `AddSchedules` instead.
        async fn create_schedules(
            &self,
            request: tonic::Request<super::CreateSchedulesRequest>,
        ) -> std::result::Result<tonic::Response<super::CreateSchedulesResponse>, tonic::Status>
        {
            Err(tonic::Status::unimplemented("Not yet implemented"))
        }
        /// Add schedules.
        async fn add_schedules(
            &self,
            request: tonic::Request<super::AddSchedulesRequest>,
        ) -> std::result::Result<tonic::Response<super::AddSchedulesResponse>, tonic::Status>
        {
            Err(tonic::Status::unimplemented("Not yet implemented"))
        }
        /// Add a schedule or return the first schedule that matches the given filter.
        ///
        /// This is semantically equivalent to sending a `CountSchedules` request
        /// and adding the schedule if the count is 0.
        /// The difference is that this method is atomic thus it is
        /// not possible for another client to add the same schedule
        /// between the `CountSchedules` and `CreateSchedules` calls.
        async fn add_schedule_if_not_exists(
            &self,
            request: tonic::Request<super::AddScheduleIfNotExistsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::AddScheduleIfNotExistsResponse>,
            tonic::Status,
        > {
            Err(tonic::Status::unimplemented("Not yet implemented"))
        }
        /// List schedules.
        async fn list_schedules(
            &self,
            request: tonic::Request<super::ListSchedulesRequest>,
        ) -> std::result::Result<tonic::Response<super::ListSchedulesResponse>, tonic::Status>
        {
            Err(tonic::Status::unimplemented("Not yet implemented"))
        }
        /// Count the number of schedules.
        async fn count_schedules(
            &self,
            request: tonic::Request<super::CountSchedulesRequest>,
        ) -> std::result::Result<tonic::Response<super::CountSchedulesResponse>, tonic::Status>
        {
            Err(tonic::Status::unimplemented("Not yet implemented"))
        }
        /// Cancel schedules.
        async fn cancel_schedules(
            &self,
            request: tonic::Request<super::CancelSchedulesRequest>,
        ) -> std::result::Result<tonic::Response<super::CancelSchedulesResponse>, tonic::Status>
        {
            Err(tonic::Status::unimplemented("Not yet implemented"))
        }
        /// Delete inactive schedules from storage.
        async fn delete_inactive_schedules(
            &self,
            request: tonic::Request<super::DeleteInactiveSchedulesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::DeleteInactiveSchedulesResponse>,
            tonic::Status,
        > {
            Err(tonic::Status::unimplemented("Not yet implemented"))
        }
    }
    /// A service that provides administrative functionality.
    #[derive(Debug)]
    pub struct AdminServiceServer<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> AdminServiceServer<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 AdminServiceServer<T>
    where
        T: AdminService,
        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() {
                "/ora.server.v1.AdminService/AddJobs" => {
                    #[allow(non_camel_case_types)]
                    struct AddJobsSvc<T: AdminService>(pub Arc<T>);
                    impl<T: AdminService> tonic::server::UnaryService<super::AddJobsRequest> for AddJobsSvc<T> {
                        type Response = super::AddJobsResponse;
                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::AddJobsRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut =
                                async move { <T as AdminService>::add_jobs(&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 = AddJobsSvc(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)
                }
                "/ora.server.v1.AdminService/AddJobIfNotExists" => {
                    #[allow(non_camel_case_types)]
                    struct AddJobIfNotExistsSvc<T: AdminService>(pub Arc<T>);
                    impl<T: AdminService>
                        tonic::server::UnaryService<super::AddJobIfNotExistsRequest>
                        for AddJobIfNotExistsSvc<T>
                    {
                        type Response = super::AddJobIfNotExistsResponse;
                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::AddJobIfNotExistsRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as AdminService>::add_job_if_not_exists(&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 = AddJobIfNotExistsSvc(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)
                }
                "/ora.server.v1.AdminService/ListJobs" => {
                    #[allow(non_camel_case_types)]
                    struct ListJobsSvc<T: AdminService>(pub Arc<T>);
                    impl<T: AdminService> tonic::server::UnaryService<super::ListJobsRequest> for ListJobsSvc<T> {
                        type Response = super::ListJobsResponse;
                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ListJobsRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as AdminService>::list_jobs(&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 = ListJobsSvc(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)
                }
                "/ora.server.v1.AdminService/CountJobs" => {
                    #[allow(non_camel_case_types)]
                    struct CountJobsSvc<T: AdminService>(pub Arc<T>);
                    impl<T: AdminService> tonic::server::UnaryService<super::CountJobsRequest> for CountJobsSvc<T> {
                        type Response = super::CountJobsResponse;
                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::CountJobsRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as AdminService>::count_jobs(&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 = CountJobsSvc(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)
                }
                "/ora.server.v1.AdminService/ListJobTypes" => {
                    #[allow(non_camel_case_types)]
                    struct ListJobTypesSvc<T: AdminService>(pub Arc<T>);
                    impl<T: AdminService> tonic::server::UnaryService<super::ListJobTypesRequest>
                        for ListJobTypesSvc<T>
                    {
                        type Response = super::ListJobTypesResponse;
                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ListJobTypesRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as AdminService>::list_job_types(&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 = ListJobTypesSvc(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)
                }
                "/ora.server.v1.AdminService/CancelJobs" => {
                    #[allow(non_camel_case_types)]
                    struct CancelJobsSvc<T: AdminService>(pub Arc<T>);
                    impl<T: AdminService> tonic::server::UnaryService<super::CancelJobsRequest> for CancelJobsSvc<T> {
                        type Response = super::CancelJobsResponse;
                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::CancelJobsRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as AdminService>::cancel_jobs(&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 = CancelJobsSvc(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)
                }
                "/ora.server.v1.AdminService/DeleteInactiveJobs" => {
                    #[allow(non_camel_case_types)]
                    struct DeleteInactiveJobsSvc<T: AdminService>(pub Arc<T>);
                    impl<T: AdminService>
                        tonic::server::UnaryService<super::DeleteInactiveJobsRequest>
                        for DeleteInactiveJobsSvc<T>
                    {
                        type Response = super::DeleteInactiveJobsResponse;
                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::DeleteInactiveJobsRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as AdminService>::delete_inactive_jobs(&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 = DeleteInactiveJobsSvc(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)
                }
                "/ora.server.v1.AdminService/ListExecutors" => {
                    #[allow(non_camel_case_types)]
                    struct ListExecutorsSvc<T: AdminService>(pub Arc<T>);
                    impl<T: AdminService> tonic::server::UnaryService<super::ListExecutorsRequest>
                        for ListExecutorsSvc<T>
                    {
                        type Response = super::ListExecutorsResponse;
                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ListExecutorsRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as AdminService>::list_executors(&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 = ListExecutorsSvc(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)
                }
                "/ora.server.v1.AdminService/CreateSchedules" => {
                    #[allow(non_camel_case_types)]
                    struct CreateSchedulesSvc<T: AdminService>(pub Arc<T>);
                    impl<T: AdminService> tonic::server::UnaryService<super::CreateSchedulesRequest>
                        for CreateSchedulesSvc<T>
                    {
                        type Response = super::CreateSchedulesResponse;
                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::CreateSchedulesRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as AdminService>::create_schedules(&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 = CreateSchedulesSvc(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)
                }
                "/ora.server.v1.AdminService/AddSchedules" => {
                    #[allow(non_camel_case_types)]
                    struct AddSchedulesSvc<T: AdminService>(pub Arc<T>);
                    impl<T: AdminService> tonic::server::UnaryService<super::AddSchedulesRequest>
                        for AddSchedulesSvc<T>
                    {
                        type Response = super::AddSchedulesResponse;
                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::AddSchedulesRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as AdminService>::add_schedules(&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 = AddSchedulesSvc(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)
                }
                "/ora.server.v1.AdminService/AddScheduleIfNotExists" => {
                    #[allow(non_camel_case_types)]
                    struct AddScheduleIfNotExistsSvc<T: AdminService>(pub Arc<T>);
                    impl<T: AdminService>
                        tonic::server::UnaryService<super::AddScheduleIfNotExistsRequest>
                        for AddScheduleIfNotExistsSvc<T>
                    {
                        type Response = super::AddScheduleIfNotExistsResponse;
                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::AddScheduleIfNotExistsRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as AdminService>::add_schedule_if_not_exists(&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 = AddScheduleIfNotExistsSvc(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)
                }
                "/ora.server.v1.AdminService/ListSchedules" => {
                    #[allow(non_camel_case_types)]
                    struct ListSchedulesSvc<T: AdminService>(pub Arc<T>);
                    impl<T: AdminService> tonic::server::UnaryService<super::ListSchedulesRequest>
                        for ListSchedulesSvc<T>
                    {
                        type Response = super::ListSchedulesResponse;
                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ListSchedulesRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as AdminService>::list_schedules(&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 = ListSchedulesSvc(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)
                }
                "/ora.server.v1.AdminService/CountSchedules" => {
                    #[allow(non_camel_case_types)]
                    struct CountSchedulesSvc<T: AdminService>(pub Arc<T>);
                    impl<T: AdminService> tonic::server::UnaryService<super::CountSchedulesRequest>
                        for CountSchedulesSvc<T>
                    {
                        type Response = super::CountSchedulesResponse;
                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::CountSchedulesRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as AdminService>::count_schedules(&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 = CountSchedulesSvc(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)
                }
                "/ora.server.v1.AdminService/CancelSchedules" => {
                    #[allow(non_camel_case_types)]
                    struct CancelSchedulesSvc<T: AdminService>(pub Arc<T>);
                    impl<T: AdminService> tonic::server::UnaryService<super::CancelSchedulesRequest>
                        for CancelSchedulesSvc<T>
                    {
                        type Response = super::CancelSchedulesResponse;
                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::CancelSchedulesRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as AdminService>::cancel_schedules(&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 = CancelSchedulesSvc(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)
                }
                "/ora.server.v1.AdminService/DeleteInactiveSchedules" => {
                    #[allow(non_camel_case_types)]
                    struct DeleteInactiveSchedulesSvc<T: AdminService>(pub Arc<T>);
                    impl<T: AdminService>
                        tonic::server::UnaryService<super::DeleteInactiveSchedulesRequest>
                        for DeleteInactiveSchedulesSvc<T>
                    {
                        type Response = super::DeleteInactiveSchedulesResponse;
                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::DeleteInactiveSchedulesRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as AdminService>::delete_inactive_schedules(&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 = DeleteInactiveSchedulesSvc(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 AdminServiceServer<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 = "ora.server.v1.AdminService";
    impl<T> tonic::server::NamedService for AdminServiceServer<T> {
        const NAME: &'static str = SERVICE_NAME;
    }
}