gitverse-sdk 1.2.0

// Code generated by gitverse-codegen. DO NOT EDIT.

use crate::client::{Client, decode_response, handle_empty_response};
use crate::errors::Error;
use crate::types::*;

impl Client {
    /// Returns a list of self-hosted runners for an organization
    pub async fn list_org_runners(
        &self,
        org: &str,
        opts: Option<&QueryOptions>,
    ) -> Result<ActionRunners, Error> {
        let path = format!("/orgs/{}/actions/runners", org);
        let resp = self.send_get(&path, opts).await?;
        decode_response(resp).await
    }

    /// Creates a registration token for an organization runner
    pub async fn create_org_runner_registration_token(
        &self,
        org: &str,
    ) -> Result<RegistrationToken, Error> {
        let path = format!("/orgs/{}/actions/runners/registration-token", org);
        let resp = self.send_post(&path, Option::<&()>::None).await?;
        decode_response(resp).await
    }

    /// Gets a specific self-hosted runner for an organization
    pub async fn get_org_runner(&self, org: &str, runner_id: f64) -> Result<ActionRunner, Error> {
        let path = format!("/orgs/{}/actions/runners/{}", org, runner_id);
        let resp = self.send_get(&path, None).await?;
        decode_response(resp).await
    }

    /// Deletes a specific self-hosted runner from the organization
    pub async fn delete_org_runner(&self, org: &str, runner_id: f64) -> Result<(), Error> {
        let path = format!("/orgs/{}/actions/runners/{}", org, runner_id);
        let resp = self.send_delete(&path, Option::<&()>::None).await?;
        handle_empty_response(resp).await
    }

    /// List organization variables
    pub async fn list_org_variables(
        &self,
        org: &str,
        opts: Option<&QueryOptions>,
    ) -> Result<VariableList, Error> {
        let path = format!("/orgs/{}/actions/variables", org);
        let resp = self.send_get(&path, opts).await?;
        decode_response(resp).await
    }

    /// Create an organization variable
    pub async fn create_org_variable(
        &self,
        org: &str,
        params: &CreateVariableParams,
    ) -> Result<(), Error> {
        let path = format!("/orgs/{}/actions/variables", org);
        let resp = self.send_post(&path, Some(params)).await?;
        handle_empty_response(resp).await
    }

    /// Get an organization variable
    pub async fn get_org_variable(&self, org: &str, name: &str) -> Result<Variable, Error> {
        let path = format!("/orgs/{}/actions/variables/{}", org, name);
        let resp = self.send_get(&path, None).await?;
        decode_response(resp).await
    }

    /// Update an organization variable
    pub async fn update_org_variable(
        &self,
        org: &str,
        name: &str,
        params: &CreateVariableParams,
    ) -> Result<(), Error> {
        let path = format!("/orgs/{}/actions/variables/{}", org, name);
        let resp = self.send_patch(&path, Some(params)).await?;
        handle_empty_response(resp).await
    }

    /// Delete an organization variable
    pub async fn delete_org_variable(&self, org: &str, name: &str) -> Result<(), Error> {
        let path = format!("/orgs/{}/actions/variables/{}", org, name);
        let resp = self.send_delete(&path, Option::<&()>::None).await?;
        handle_empty_response(resp).await
    }

    /// Returns a list of artifacts in the repository
    pub async fn list_artifacts(
        &self,
        owner: &str,
        repo: &str,
        opts: Option<&QueryOptions>,
    ) -> Result<ActionArtifactList, Error> {
        let path = format!("/repos/{}/{}/actions/artifacts", owner, repo);
        let resp = self.send_get(&path, opts).await?;
        decode_response(resp).await
    }

    /// Returns a specific artifact from the repository
    pub async fn get_artifact(
        &self,
        owner: &str,
        repo: &str,
        artifact_id: &str,
    ) -> Result<ActionArtifact, Error> {
        let path = format!(
            "/repos/{}/{}/actions/artifacts/{}",
            owner, repo, artifact_id
        );
        let resp = self.send_get(&path, None).await?;
        decode_response(resp).await
    }

    /// Deletes a specific artifact
    pub async fn delete_artifact(
        &self,
        owner: &str,
        repo: &str,
        artifact_id: &str,
    ) -> Result<(), Error> {
        let path = format!(
            "/repos/{}/{}/actions/artifacts/{}",
            owner, repo, artifact_id
        );
        let resp = self.send_delete(&path, Option::<&()>::None).await?;
        handle_empty_response(resp).await
    }

    /// Downloads a specific artifact as a ZIP archive
    pub async fn download_artifact(
        &self,
        owner: &str,
        repo: &str,
        artifact_id: &str,
    ) -> Result<(), Error> {
        let path = format!(
            "/repos/{}/{}/actions/artifacts/{}/zip",
            owner, repo, artifact_id
        );
        let resp = self.send_get(&path, None).await?;
        handle_empty_response(resp).await
    }

    /// Downloads the artifact ZIP archive directly
    pub async fn download_artifact_raw(
        &self,
        owner: &str,
        repo: &str,
        artifact_id: &str,
    ) -> Result<String, Error> {
        let path = format!(
            "/repos/{}/{}/actions/artifacts/{}/zip/raw",
            owner, repo, artifact_id
        );
        let resp = self.send_get(&path, None).await?;
        decode_response(resp).await
    }

    /// Get a workflow run job
    pub async fn get_workflow_job(
        &self,
        owner: &str,
        repo: &str,
        job_id: f64,
    ) -> Result<ActionRunJob, Error> {
        let path = format!("/repos/{}/{}/actions/jobs/{}", owner, repo, job_id);
        let resp = self.send_get(&path, None).await?;
        decode_response(resp).await
    }

    /// Get workflow run job logs
    pub async fn get_workflow_job_logs(
        &self,
        owner: &str,
        repo: &str,
        job_id: f64,
    ) -> Result<(), Error> {
        let path = format!("/repos/{}/{}/actions/jobs/{}/logs", owner, repo, job_id);
        let resp = self.send_get(&path, None).await?;
        handle_empty_response(resp).await
    }

    /// Adds a link to an action run
    pub async fn create_action_link(
        &self,
        owner: &str,
        repo: &str,
        params: &CreateActionLinkParams,
    ) -> Result<ActionLink, Error> {
        let path = format!("/repos/{}/{}/actions/links", owner, repo);
        let resp = self.send_post(&path, Some(params)).await?;
        decode_response(resp).await
    }

    /// Returns a list of runners for the repository
    pub async fn list_repo_runners(
        &self,
        owner: &str,
        repo: &str,
        opts: Option<&QueryOptions>,
    ) -> Result<ActionRunners, Error> {
        let path = format!("/repos/{}/{}/actions/runners", owner, repo);
        let resp = self.send_get(&path, opts).await?;
        decode_response(resp).await
    }

    /// Creates a registration token for a repository runner
    pub async fn create_repo_runner_registration_token(
        &self,
        owner: &str,
        repo: &str,
    ) -> Result<RegistrationToken, Error> {
        let path = format!(
            "/repos/{}/{}/actions/runners/registration-token",
            owner, repo
        );
        let resp = self.send_post(&path, Option::<&()>::None).await?;
        decode_response(resp).await
    }

    /// Gets a specific runner for a repository
    pub async fn get_repo_runner(
        &self,
        owner: &str,
        repo: &str,
        runner_id: f64,
    ) -> Result<ActionRunner, Error> {
        let path = format!("/repos/{}/{}/actions/runners/{}", owner, repo, runner_id);
        let resp = self.send_get(&path, None).await?;
        decode_response(resp).await
    }

    /// Deletes a specific self-hosted runner from the repository
    pub async fn delete_repo_runner(
        &self,
        owner: &str,
        repo: &str,
        runner_id: f64,
    ) -> Result<(), Error> {
        let path = format!("/repos/{}/{}/actions/runners/{}", owner, repo, runner_id);
        let resp = self.send_delete(&path, Option::<&()>::None).await?;
        handle_empty_response(resp).await
    }

    /// List workflow runs
    pub async fn list_workflow_runs(
        &self,
        owner: &str,
        repo: &str,
        opts: Option<&QueryOptions>,
    ) -> Result<RunsResponse, Error> {
        let path = format!("/repos/{}/{}/actions/runs", owner, repo);
        let resp = self.send_get(&path, opts).await?;
        decode_response(resp).await
    }

    /// Get a workflow run by index
    pub async fn get_workflow_run_by_index(
        &self,
        owner: &str,
        repo: &str,
        run_index: f64,
    ) -> Result<ActionRun, Error> {
        let path = format!("/repos/{}/{}/actions/runs/index/{}", owner, repo, run_index);
        let resp = self.send_get(&path, None).await?;
        decode_response(resp).await
    }

    /// List workflow run jobs by index
    pub async fn list_workflow_run_jobs_by_index(
        &self,
        owner: &str,
        repo: &str,
        run_index: f64,
        opts: Option<&QueryOptions>,
    ) -> Result<JobsResponse, Error> {
        let path = format!(
            "/repos/{}/{}/actions/runs/index/{}/jobs",
            owner, repo, run_index
        );
        let resp = self.send_get(&path, opts).await?;
        decode_response(resp).await
    }

    /// Get a workflow run
    pub async fn get_workflow_run(
        &self,
        owner: &str,
        repo: &str,
        run_id: f64,
    ) -> Result<ActionRun, Error> {
        let path = format!("/repos/{}/{}/actions/runs/{}", owner, repo, run_id);
        let resp = self.send_get(&path, None).await?;
        decode_response(resp).await
    }

    /// List workflow run jobs
    pub async fn list_workflow_run_jobs(
        &self,
        owner: &str,
        repo: &str,
        run_id: f64,
        opts: Option<&QueryOptions>,
    ) -> Result<JobsResponse, Error> {
        let path = format!("/repos/{}/{}/actions/runs/{}/jobs", owner, repo, run_id);
        let resp = self.send_get(&path, opts).await?;
        decode_response(resp).await
    }

    /// List repository variables
    pub async fn list_repo_variables(
        &self,
        owner: &str,
        repo: &str,
        opts: Option<&QueryOptions>,
    ) -> Result<VariableList, Error> {
        let path = format!("/repos/{}/{}/actions/variables", owner, repo);
        let resp = self.send_get(&path, opts).await?;
        decode_response(resp).await
    }

    /// Create a repository variable
    pub async fn create_repo_variable(
        &self,
        owner: &str,
        repo: &str,
        params: &CreateVariableParams,
    ) -> Result<(), Error> {
        let path = format!("/repos/{}/{}/actions/variables", owner, repo);
        let resp = self.send_post(&path, Some(params)).await?;
        handle_empty_response(resp).await
    }

    /// Get a repository variable
    pub async fn get_repo_variable(
        &self,
        owner: &str,
        repo: &str,
        name: &str,
    ) -> Result<Variable, Error> {
        let path = format!("/repos/{}/{}/actions/variables/{}", owner, repo, name);
        let resp = self.send_get(&path, None).await?;
        decode_response(resp).await
    }

    /// Update a repository variable
    pub async fn update_repo_variable(
        &self,
        owner: &str,
        repo: &str,
        name: &str,
        params: &CreateVariableParams,
    ) -> Result<(), Error> {
        let path = format!("/repos/{}/{}/actions/variables/{}", owner, repo, name);
        let resp = self.send_patch(&path, Some(params)).await?;
        handle_empty_response(resp).await
    }

    /// Delete a repository variable
    pub async fn delete_repo_variable(
        &self,
        owner: &str,
        repo: &str,
        name: &str,
    ) -> Result<(), Error> {
        let path = format!("/repos/{}/{}/actions/variables/{}", owner, repo, name);
        let resp = self.send_delete(&path, Option::<&()>::None).await?;
        handle_empty_response(resp).await
    }

    /// Get workflow_dispatch parameters
    pub async fn get_workflow_dispatch_inputs(
        &self,
        owner: &str,
        repo: &str,
        workflow: &str,
        opts: Option<&QueryOptions>,
    ) -> Result<WorkflowDispatchInputList, Error> {
        let path = format!(
            "/repos/{}/{}/actions/workflows/{}/dispatches",
            owner, repo, workflow
        );
        let resp = self.send_get(&path, opts).await?;
        decode_response(resp).await
    }

    /// Trigger workflow_dispatch
    pub async fn dispatch_workflow(
        &self,
        owner: &str,
        repo: &str,
        workflow: &str,
        params: &serde_json::Value,
        _opts: Option<&QueryOptions>,
    ) -> Result<(), Error> {
        let path = format!(
            "/repos/{}/{}/actions/workflows/{}/dispatches",
            owner, repo, workflow
        );
        let resp = self.send_post(&path, Some(params)).await?;
        handle_empty_response(resp).await
    }
}