spiral-sdk 0.1.10

// Generated by tools/service-contracts/rust.py. Do not edit.
#![doc = "Generated implementation of authenticated SDK resource facades."]
use spiral_contract::call::CallError;
use uuid::Uuid;

use crate::api::tasks::TasksClient;
use crate::api::tasks::objects::*;
use crate::auth::TokenSource;
use crate::http::HttpClient;
/// Service operations sharing a connection pool and resolving credentials for every request.
#[derive(Clone, Debug)]
pub struct AuthenticatedClient {
    http: HttpClient,
    client: TasksClient,
}
impl AuthenticatedClient {
    /// Connect with bounded requests; configure credentials before authenticated calls.
    pub fn new(base: &str) -> Result<Self, CallError<TasksError>> {
        Self::from_http(HttpClient::connect(base).map_err(CallError::transport)?)
    }
    pub(crate) fn from_http(http: HttpClient) -> Result<Self, CallError<TasksError>> {
        let client =
            TasksClient::from_transport(http.base_url().as_str(), http.middleware_client())?;
        Ok(Self { http, client })
    }
    /// Reuse a connection pool with redirects disabled to protect bearer credentials.
    pub fn with_client(mut self, client: reqwest::Client) -> Self {
        self.http = self.http.with_client(client);
        self.client = self.client.with_transport(self.http.middleware_client());
        self
    }
    /// Resolve the provider's current credential before each request and pagination fetch.
    pub fn with_token_source(mut self, provider: TokenSource) -> Self {
        self.http = self.http.with_token_source(provider);
        self
    }
    /// Activate one Worker pool.
    pub async fn activate_worker_pool(
        &self,
        project_id: String,
        worker_pool_id: Uuid,
    ) -> Result<WorkerPoolResponse, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client
                .activate_worker_pool_http(auth_header, project_id, worker_pool_id),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Cancel a Task through a Project. Deprecated; use cancel_task, which derives the Project.
    pub async fn cancel_project_task(
        &self,
        project_id: String,
        task_id: Uuid,
    ) -> Result<Task, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client
                .cancel_project_task_http(auth_header, project_id, task_id),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Request cancellation of a Task. The Task's own Project authorizes the request; a Task the
    /// caller cannot view is not found.
    pub async fn cancel_task(&self, task_id: Uuid) -> Result<Task, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client.cancel_task_http(auth_header, task_id),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Claim worker task.
    pub async fn claim_worker_task(
        &self,
        worker_session_id: Uuid,
        task_id: Uuid,
    ) -> Result<PollTaskResponse, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client
                .claim_worker_task_http(auth_header, worker_session_id, task_id),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Create a Task from a specification ID and JSON input. Deprecated; use submit_task.
    pub async fn create_task(
        &self,
        project_id: String,
        request: CreateTaskRequest,
    ) -> Result<CreateTaskResponse, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client
                .create_task_http(auth_header, project_id, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Create trigger.
    pub async fn create_trigger(
        &self,
        project_id: String,
        request: TriggerDefinition,
    ) -> Result<TaskTrigger, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client
                .create_trigger_http(auth_header, project_id, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Create worker pool.
    pub async fn create_worker_pool(
        &self,
        project_id: String,
        request: CreateWorkerPoolRequest,
    ) -> Result<WorkerPoolResponse, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client
                .create_worker_pool_http(auth_header, project_id, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Delete trigger.
    pub async fn delete_trigger(
        &self,
        project_id: String,
        trigger_id: Uuid,
    ) -> Result<(), CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client
                .delete_trigger_http(auth_header, project_id, trigger_id),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Drain worker.
    pub async fn drain_worker(
        &self,
        worker_session_id: Uuid,
    ) -> Result<DrainWorkerResponse, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client
                .drain_worker_http(auth_header, worker_session_id),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Finish worker attempt.
    pub async fn finish_worker_attempt(
        &self,
        worker_session_id: Uuid,
        attempt_id: Uuid,
        request: FinishAttemptRequest,
    ) -> Result<FinishAttemptResponse, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client.finish_worker_attempt_http(
                auth_header,
                worker_session_id,
                attempt_id,
                request,
            ),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Heartbeat worker.
    pub async fn heartbeat_worker(
        &self,
        worker_session_id: Uuid,
        request: HeartbeatWorkerRequest,
    ) -> Result<HeartbeatWorkerResponse, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client
                .heartbeat_worker_http(auth_header, worker_session_id, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// List task specs.
    pub async fn list_task_specs(
        &self,
        project_id: String,
    ) -> Result<ListTaskSpecsResponse, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client.list_task_specs_http(auth_header, project_id),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// List Tasks by descending Task ID. Pages default to 100 items with a maximum of 1000.
    /// Continuations expire after one hour and are scoped to the caller, target, operation, filters
    /// and page size. This is a live listing; concurrent updates can change later pages.
    pub async fn list_tasks(
        &self,
        project_id: String,
        request: ListTasksRequest,
    ) -> Result<ListTasksResponse, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client
                .list_tasks_http(auth_header, project_id, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Build a lazy collection, retaining filters and resolving fresh credentials for each page.
    pub fn list_tasks_list(
        &self,
        project_id: String,
        request: ListTasksRequest,
    ) -> crate::List<'_, Task> {
        let options = crate::pagination::PageOptions {
            token: request.page_token.clone(),
            size: request.page_size,
        };
        crate::List::new(move |options| {
            let project_id = ToOwned::to_owned(&project_id);
            let mut request = request.clone();
            request.page_token = options.token;
            request.page_size = options.size;
            Box::pin(async move {
                let page = self.list_tasks(project_id, request).await?;
                Ok(crate::Page {
                    items: page.tasks,
                    next_page_token: page.next_page_token,
                })
            })
        })
        .with_options(options)
    }
    /// List invocations by descending submission time and Task ID in fixed pages of 10.
    /// Continuations expire after one hour and are scoped to the caller, target, operation, filters
    /// and page size. This is a live listing; concurrent updates can change later pages.
    pub async fn list_trigger_invocations(
        &self,
        project_id: String,
        trigger_id: Uuid,
        request: InvocationPageRequest,
    ) -> Result<InvocationPage, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client
                .list_trigger_invocations_http(auth_header, project_id, trigger_id, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// List triggers by descending trigger ID in fixed pages of 50. Continuations expire after one
    /// hour and are scoped to the caller, target, operation, filters and page size. This is a live
    /// listing; concurrent updates can change later pages.
    pub async fn list_triggers(
        &self,
        project_id: String,
        request: TriggerPageRequest,
    ) -> Result<TriggerPage, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client
                .list_triggers_http(auth_header, project_id, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// List Attempts by descending Attempt ID. Pages default to 100 items with a maximum of 100.
    /// Continuations expire after one hour and are scoped to the caller, target, operation, filters
    /// and page size. This is a live listing; concurrent updates can change later pages.
    pub async fn list_worker_attempts(
        &self,
        project_id: String,
        worker_session_id: Uuid,
        request: ListWorkerAttemptsRequest,
    ) -> Result<ListWorkerAttemptsResponse, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client.list_worker_attempts_http(
                auth_header,
                project_id,
                worker_session_id,
                request,
            ),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Build a lazy collection, retaining filters and resolving fresh credentials for each page.
    pub fn list_worker_attempts_list(
        &self,
        project_id: String,
        worker_session_id: Uuid,
        request: ListWorkerAttemptsRequest,
    ) -> crate::List<'_, WorkerAttempt> {
        let options = crate::pagination::PageOptions {
            token: request.page_token.clone(),
            size: request.page_size,
        };
        crate::List::new(move |options| {
            let project_id = ToOwned::to_owned(&project_id);
            let worker_session_id = ToOwned::to_owned(&worker_session_id);
            let mut request = request.clone();
            request.page_token = options.token;
            request.page_size = options.size;
            Box::pin(async move {
                let page = self
                    .list_worker_attempts(project_id, worker_session_id, request)
                    .await?;
                Ok(crate::Page {
                    items: page.attempts,
                    next_page_token: page.next_page_token,
                })
            })
        })
        .with_options(options)
    }
    /// List Worker pools and aligned statistics by ascending pool ID. Pages default to 100 items
    /// with a maximum of 1000. Continuations expire after one hour and are scoped to the caller,
    /// target, operation, filters and page size. This is a live listing; concurrent updates can
    /// change later pages.
    pub async fn list_worker_pools(
        &self,
        project_id: String,
        request: ListWorkerPoolsRequest,
    ) -> Result<ListWorkerPoolsResponse, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client
                .list_worker_pools_http(auth_header, project_id, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Build a lazy collection, retaining filters and resolving fresh credentials for each page.
    pub fn list_worker_pools_list(
        &self,
        project_id: String,
        request: ListWorkerPoolsRequest,
    ) -> crate::List<'_, WorkerPool> {
        let options = crate::pagination::PageOptions {
            token: request.page_token.clone(),
            size: request.page_size,
        };
        crate::List::new(move |options| {
            let project_id = ToOwned::to_owned(&project_id);
            let mut request = request.clone();
            request.page_token = options.token;
            request.page_size = options.size;
            Box::pin(async move {
                let page = self.list_worker_pools(project_id, request).await?;
                Ok(crate::Page {
                    items: page.worker_pools,
                    next_page_token: page.next_page_token,
                })
            })
        })
        .with_options(options)
    }
    /// List Worker sessions by descending session ID. Pages default to 100 items with a maximum of
    /// 1000. Continuations expire after one hour and are scoped to the caller, target, operation,
    /// filters and page size. This is a live listing; concurrent updates can change later pages.
    pub async fn list_worker_sessions(
        &self,
        project_id: String,
        request: ListWorkerSessionsRequest,
    ) -> Result<ListWorkerSessionsResponse, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client
                .list_worker_sessions_http(auth_header, project_id, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Build a lazy collection, retaining filters and resolving fresh credentials for each page.
    pub fn list_worker_sessions_list(
        &self,
        project_id: String,
        request: ListWorkerSessionsRequest,
    ) -> crate::List<'_, WorkerSession> {
        let options = crate::pagination::PageOptions {
            token: request.page_token.clone(),
            size: request.page_size,
        };
        crate::List::new(move |options| {
            let project_id = ToOwned::to_owned(&project_id);
            let mut request = request.clone();
            request.page_token = options.token;
            request.page_size = options.size;
            Box::pin(async move {
                let page = self.list_worker_sessions(project_id, request).await?;
                Ok(crate::Page {
                    items: page.worker_sessions,
                    next_page_token: page.next_page_token,
                })
            })
        })
        .with_options(options)
    }
    /// Pause one Worker pool.
    pub async fn pause_worker_pool(
        &self,
        project_id: String,
        worker_pool_id: Uuid,
    ) -> Result<WorkerPoolResponse, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client
                .pause_worker_pool_http(auth_header, project_id, worker_pool_id),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Poll worker.
    pub async fn poll_worker(
        &self,
        worker_session_id: Uuid,
    ) -> Result<PollTaskResponse, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client.poll_worker_http(auth_header, worker_session_id),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Read a Task through a Project. Deprecated; use read_task, which derives the Project.
    pub async fn read_project_task(
        &self,
        project_id: String,
        task_id: Uuid,
    ) -> Result<TaskDetails, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client
                .read_project_task_http(auth_header, project_id, task_id),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Read resource usage.
    pub async fn read_resource_usage(
        &self,
        project_id: String,
        worker_session_id: Uuid,
        request: ResourceUsageRequest,
    ) -> Result<ResourceUsageHistory, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client.read_resource_usage_http(
                auth_header,
                project_id,
                worker_session_id,
                request,
            ),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Read a Task with its Attempts and resource references. The Task's own Project authorizes the
    /// read; a Task the caller cannot view is not found.
    pub async fn read_task(&self, task_id: Uuid) -> Result<TaskDetails, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client.read_task_http(auth_header, task_id),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Read task stats.
    pub async fn read_task_stats(
        &self,
        project_id: String,
        request: TaskStatsRequest,
    ) -> Result<TaskStats, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client
                .read_task_stats_http(auth_header, project_id, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Read trigger.
    pub async fn read_trigger(
        &self,
        project_id: String,
        trigger_id: Uuid,
    ) -> Result<TaskTrigger, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client
                .read_trigger_http(auth_header, project_id, trigger_id),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Read worker pool.
    pub async fn read_worker_pool(
        &self,
        project_id: String,
        worker_pool_id: Uuid,
    ) -> Result<WorkerPoolDetails, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client
                .read_worker_pool_http(auth_header, project_id, worker_pool_id),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Read worker session.
    pub async fn read_worker_session(
        &self,
        project_id: String,
        worker_session_id: Uuid,
    ) -> Result<WorkerSession, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client
                .read_worker_session_http(auth_header, project_id, worker_session_id),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Register worker.
    pub async fn register_worker(
        &self,
        request: RegisterWorkerRequest,
    ) -> Result<RegisterWorkerResponse, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client.register_worker_http(auth_header, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Retire one Worker pool.
    pub async fn retire_worker_pool(
        &self,
        project_id: String,
        worker_pool_id: Uuid,
    ) -> Result<WorkerPoolResponse, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client
                .retire_worker_pool_http(auth_header, project_id, worker_pool_id),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Run trigger.
    pub async fn run_trigger(
        &self,
        project_id: String,
        trigger_id: Uuid,
        request: RunTriggerRequest,
    ) -> Result<TriggerInvocation, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client
                .run_trigger_http(auth_header, project_id, trigger_id, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Submit a Task from its definition. The response is accepted with the Task, or skipped when
    /// the definition's overlap policy keeps an equivalent Task already waiting.
    pub async fn submit_task(
        &self,
        project_id: String,
        request: SubmitTaskRequest,
    ) -> Result<CreateTaskResponse, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client
                .submit_task_http(auth_header, project_id, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Test trigger.
    pub async fn test_trigger(
        &self,
        project_id: String,
        trigger_id: Uuid,
        request: TestTriggerRequest,
    ) -> Result<TestTriggerResponse, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client
                .test_trigger_http(auth_header, project_id, trigger_id, request),
        )
        .await
        .map_err(CallError::transport)?
    }
    /// Update trigger.
    pub async fn update_trigger(
        &self,
        project_id: String,
        trigger_id: Uuid,
        request: UpdateTriggerRequest,
    ) -> Result<TaskTrigger, CallError<TasksError>> {
        let auth_header = self
            .http
            .auth_header()
            .await
            .map_err(CallError::transport)?;
        tokio::time::timeout(
            std::time::Duration::from_secs(10),
            self.client
                .update_trigger_http(auth_header, project_id, trigger_id, request),
        )
        .await
        .map_err(CallError::transport)?
    }
}