Struct ProjectsService 

pub struct ProjectsService<'a> { /* private fields */ }

Service for projects, project statuses, and project milestones. Obtain via LinearClient::projects.

Implementations

impl<'a> ProjectsService<'a>

pub async fn list(&self, request: ListProjectsRequest) -> Result<Page<Project>>

Fetches one page of projects.

use linear_api::projects::ListProjectsRequest;

let page = client
    .projects()
    .list(ListProjectsRequest::builder().first(50).build())
    .await?;
println!("{} projects, more: {}", page.nodes.len(), page.page_info.has_next_page);

pub fn list_stream( &self, request: ListProjectsRequest, ) -> impl Stream<Item = Result<Project>> + 'a

Lazily streams every project matching request across pages, starting from request.after when set (the cursor then advances page by page). See crate::paginate for the complexity trade-offs.

use futures::TryStreamExt;
use linear_api::projects::ListProjectsRequest;

let projects: Vec<_> = client
    .projects()
    .list_stream(ListProjectsRequest::builder().first(50).build())
    .try_collect()
    .await?;

pub async fn get(&self, id: &ProjectId) -> Result<Project>

Fetches a single project by ID. Linear also resolves slug IDs (the identifier from the project URL) passed as a ProjectId.

let id = linear_api::ProjectId::new("sdk-v1-8f2a1c0d3b4e");
let project = client.projects().get(&id).await?;
println!("{} — {:.0}% done", project.name, project.progress * 100.0);

pub async fn create(&self, input: ProjectCreateInput) -> Result<Project>

Creates a project.

use linear_api::TeamId;
use linear_api::projects::ProjectCreateInput;

let project = client
    .projects()
    .create(
        ProjectCreateInput::builder()
            .name("SDK v1".to_owned())
            .team_ids(vec![TeamId::new("team-1")])
            .build(),
    )
    .await?;

pub async fn update( &self, id: &ProjectId, input: ProjectUpdateInput, ) -> Result<Project>

Updates a project (Linear’s projectUpdate mutation, not the ProjectUpdate status-post entity). Undefinable fields on the input distinguish leave-unchanged from clear from set.

use linear_api::Undefinable;
use linear_api::projects::ProjectUpdateInput;

let id = linear_api::ProjectId::new("proj-1");
let project = client
    .projects()
    .update(
        &id,
        ProjectUpdateInput::builder()
            .target_date("2026-10-01".parse::<linear_api::TimelessDate>().unwrap())
            .lead_id(Undefinable::Null) // clear the lead
            .build(),
    )
    .await?;

pub async fn archive(&self, id: &ProjectId) -> Result<()>

Archives a project.

let id = linear_api::ProjectId::new("proj-1");
client.projects().archive(&id).await?;

pub async fn statuses(&self) -> Result<Vec<ProjectStatus>>

Fetches the workspace’s project statuses (a single page of up to 50 — workspaces define a handful).

for status in client.projects().statuses().await? {
    println!("{} ({:?})", status.name, status.status_type);
}

pub async fn milestones(&self, id: &ProjectId) -> Result<Vec<ProjectMilestone>>

Fetches every milestone of a project, draining pagination internally (pages of 50, capped at 250 milestones).

let id = linear_api::ProjectId::new("proj-1");
for milestone in client.projects().milestones(&id).await? {
    println!("{} (order {})", milestone.name, milestone.sort_order);
}

pub async fn create_milestone( &self, input: ProjectMilestoneCreateInput, ) -> Result<ProjectMilestone>

Creates a milestone within a project.

use linear_api::projects::ProjectMilestoneCreateInput;

let milestone = client
    .projects()
    .create_milestone(
        ProjectMilestoneCreateInput::builder()
            .project_id(linear_api::ProjectId::new("proj-1"))
            .name("M1 — Read path".to_owned())
            .build(),
    )
    .await?;

pub async fn update_milestone( &self, id: &ProjectMilestoneId, input: ProjectMilestoneUpdateInput, ) -> Result<ProjectMilestone>

Updates a milestone.

use linear_api::Undefinable;
use linear_api::projects::ProjectMilestoneUpdateInput;

let id = linear_api::ProjectMilestoneId::new("ms-1");
let milestone = client
    .projects()
    .update_milestone(
        &id,
        ProjectMilestoneUpdateInput::builder()
            .name("M1 — Read path (done)".to_owned())
            .target_date(Undefinable::Null) // clear the target date
            .build(),
    )
    .await?;

pub async fn delete_milestone(&self, id: &ProjectMilestoneId) -> Result<()>

Deletes a milestone.

let id = linear_api::ProjectMilestoneId::new("ms-1");
client.projects().delete_milestone(&id).await?;

Trait Implementations

impl<'a> Clone for ProjectsService<'a>

fn clone(&self) -> ProjectsService<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Copy for ProjectsService<'a>