Reference

curl "https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/ActivityService.AddActivity" \
  --request POST \
  --header 'Content-Type: application/json; charset=utf-8' \
  --header 'Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...' \
  --data '{
	"activityKind": "userNote",
	"body": "Some interesting insights from a third-party system",
	"eventTime": "2021-08-07T11:58:23Z",
	"incidentID": "incident-123"
}'

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	incident "github.com/grafana/incident-go"
)

func main() {
	ctx := context.Background()
	// create a client, and required services...
	serviceAccountToken := os.Getenv("SERVICE_ACCOUNT_TOKEN")
	client := incident.NewClient("https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1", serviceAccountToken)
	activityService := incident.NewActivityService(client)
	// make the request...
	addActivityResp, err := activityService.AddActivity(ctx, main.AddActivityRequest{
		IncidentID: "incident-123",
		ActivityKind: "userNote",
		Body: "Some interesting insights from a third-party system",
		EventTime: "2021-08-07T11:58:23Z",
	})
	if err != nil {
		// something went wrong
		fmt.Errorf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
	// use the output fields...
	log.Printf("ActivityItem: %+v\n", addActivityResp.ActivityItem)
	log.Printf("Error: %+v\n", addActivityResp.Error)

}

POST https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/ActivityService.AddActivity
Content-Type="application/json; charset=utf-8"
Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...

{
	"activityKind": "userNote",
	"body": "Some interesting insights from a third-party system",
	"eventTime": "2021-08-07T11:58:23Z",
	"incidentID": "incident-123"
}

import { GrafanaIncidentClient, ActivityService } from '@grafana/incident-node';

// https://grafana.com/docs/grafana-cloud/incident/api/auth/#get-a-service-account-token
const serviceAccountToken = process.env.GRAFANA_CLOUD_SERVICE_ACCOUNT_TOKEN;
const client = new GrafanaIncidentClient(
  "https://your-stack.grafana.net",
  serviceAccountToken
);
const activityService = new ActivityService(client);

// AddActivity posts an activity item to an Incident.
const activityServiceResp = await activityService.addActivity({
	"activityKind": "userNote",
	"body": "Some interesting insights from a third-party system",
	"eventTime": "2021-08-07T11:58:23Z",
	"incidentID": "incident-123"
});

if (!activityServiceResp.success) {
  // handle the error
  throw new Error(activityServiceResp.error);
}

// access the fields of the response
console.info({"activityItem", activityServiceResp.data.activityItem});

curl "https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/ActivityService.QueryActivity" \
  --request POST \
  --header 'Content-Type: application/json; charset=utf-8' \
  --header 'Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...' \
  --data '{
	"cursor": {
		"hasMore": true,
		"nextValue": "aaaabbbbccccddddeeeeffffgggg"
	},
	"query": {
		"activityKind": [
			"incidentCreated"
		],
		"incidentID": "incident-123",
		"limit": 10,
		"orderDirection": "ASC",
		"tag": "important"
	}
}'

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	incident "github.com/grafana/incident-go"
)

func main() {
	ctx := context.Background()
	// create a client, and required services...
	serviceAccountToken := os.Getenv("SERVICE_ACCOUNT_TOKEN")
	client := incident.NewClient("https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1", serviceAccountToken)
	activityService := incident.NewActivityService(client)
	// make the request...
	queryActivityResp, err := activityService.QueryActivity(ctx, main.QueryActivityRequest{
		Query: main.ActivityQuery{
			IncidentID: "incident-123",
			Limit: 10,
			Tag: "important",
			OrderDirection: "ASC",
			ActivityKind: ["incidentCreated"],
		},
		Cursor: main.Cursor{
			NextValue: "aaaabbbbccccddddeeeeffffgggg",
			HasMore: true,
		},
	})
	if err != nil {
		// something went wrong
		fmt.Errorf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
	// use the output fields...
	log.Printf("ActivityItems: %+v\n", queryActivityResp.ActivityItems)
	log.Printf("Query: %+v\n", queryActivityResp.Query)
	log.Printf("Cursor: %+v\n", queryActivityResp.Cursor)
	log.Printf("Error: %+v\n", queryActivityResp.Error)

}

POST https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/ActivityService.QueryActivity
Content-Type="application/json; charset=utf-8"
Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...

{
	"cursor": {
		"hasMore": true,
		"nextValue": "aaaabbbbccccddddeeeeffffgggg"
	},
	"query": {
		"activityKind": [
			"incidentCreated"
		],
		"incidentID": "incident-123",
		"limit": 10,
		"orderDirection": "ASC",
		"tag": "important"
	}
}

import { GrafanaIncidentClient, ActivityService } from '@grafana/incident-node';

// https://grafana.com/docs/grafana-cloud/incident/api/auth/#get-a-service-account-token
const serviceAccountToken = process.env.GRAFANA_CLOUD_SERVICE_ACCOUNT_TOKEN;
const client = new GrafanaIncidentClient(
  "https://your-stack.grafana.net",
  serviceAccountToken
);
const activityService = new ActivityService(client);

// QueryActivity gets a selection of activity items.
const activityServiceResp = await activityService.queryActivity({
	"cursor": {
		"hasMore": true,
		"nextValue": "aaaabbbbccccddddeeeeffffgggg"
	},
	"query": {
		"activityKind": [
			"incidentCreated"
		],
		"incidentID": "incident-123",
		"limit": 10,
		"orderDirection": "ASC",
		"tag": "important"
	}
});

if (!activityServiceResp.success) {
  // handle the error
  throw new Error(activityServiceResp.error);
}

// access the fields of the response
console.info({"activityItems", activityServiceResp.data.activityItems});
console.info({"query", activityServiceResp.data.query});
console.info({"cursor", activityServiceResp.data.cursor});

curl "https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/ActivityService.RemoveActivity" \
  --request POST \
  --header 'Content-Type: application/json; charset=utf-8' \
  --header 'Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...' \
  --data '{
	"activityItemID": "activity-item-123",
	"incidentID": "incident-123"
}'

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	incident "github.com/grafana/incident-go"
)

func main() {
	ctx := context.Background()
	// create a client, and required services...
	serviceAccountToken := os.Getenv("SERVICE_ACCOUNT_TOKEN")
	client := incident.NewClient("https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1", serviceAccountToken)
	activityService := incident.NewActivityService(client)
	// make the request...
	removeActivityResp, err := activityService.RemoveActivity(ctx, main.RemoveActivityRequest{
		IncidentID: "incident-123",
		ActivityItemID: "activity-item-123",
	})
	if err != nil {
		// something went wrong
		fmt.Errorf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
	// use the output fields...
	log.Printf("ActivityItem: %+v\n", removeActivityResp.ActivityItem)
	log.Printf("Error: %+v\n", removeActivityResp.Error)

}

POST https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/ActivityService.RemoveActivity
Content-Type="application/json; charset=utf-8"
Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...

{
	"activityItemID": "activity-item-123",
	"incidentID": "incident-123"
}

import { GrafanaIncidentClient, ActivityService } from '@grafana/incident-node';

// https://grafana.com/docs/grafana-cloud/incident/api/auth/#get-a-service-account-token
const serviceAccountToken = process.env.GRAFANA_CLOUD_SERVICE_ACCOUNT_TOKEN;
const client = new GrafanaIncidentClient(
  "https://your-stack.grafana.net",
  serviceAccountToken
);
const activityService = new ActivityService(client);

// RemoveActivity removes an activity item.
const activityServiceResp = await activityService.removeActivity({
	"activityItemID": "activity-item-123",
	"incidentID": "incident-123"
});

if (!activityServiceResp.success) {
  // handle the error
  throw new Error(activityServiceResp.error);
}

// access the fields of the response
console.info({"activityItem", activityServiceResp.data.activityItem});

curl "https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/ActivityService.UpdateActivityBody" \
  --request POST \
  --header 'Content-Type: application/json; charset=utf-8' \
  --header 'Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...' \
  --data '{
	"activityItemID": "activity-item-123",
	"body": "New contents",
	"incidentID": "incident-123"
}'

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	incident "github.com/grafana/incident-go"
)

func main() {
	ctx := context.Background()
	// create a client, and required services...
	serviceAccountToken := os.Getenv("SERVICE_ACCOUNT_TOKEN")
	client := incident.NewClient("https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1", serviceAccountToken)
	activityService := incident.NewActivityService(client)
	// make the request...
	updateActivityBodyResp, err := activityService.UpdateActivityBody(ctx, main.UpdateActivityBodyRequest{
		IncidentID: "incident-123",
		ActivityItemID: "activity-item-123",
		Body: "New contents",
	})
	if err != nil {
		// something went wrong
		fmt.Errorf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
	// use the output fields...
	log.Printf("ActivityItem: %+v\n", updateActivityBodyResp.ActivityItem)
	log.Printf("Error: %+v\n", updateActivityBodyResp.Error)

}

POST https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/ActivityService.UpdateActivityBody
Content-Type="application/json; charset=utf-8"
Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...

{
	"activityItemID": "activity-item-123",
	"body": "New contents",
	"incidentID": "incident-123"
}

import { GrafanaIncidentClient, ActivityService } from '@grafana/incident-node';

// https://grafana.com/docs/grafana-cloud/incident/api/auth/#get-a-service-account-token
const serviceAccountToken = process.env.GRAFANA_CLOUD_SERVICE_ACCOUNT_TOKEN;
const client = new GrafanaIncidentClient(
  "https://your-stack.grafana.net",
  serviceAccountToken
);
const activityService = new ActivityService(client);

// UpdateActivityBody updates the body of a specific activity item.
const activityServiceResp = await activityService.updateActivityBody({
	"activityItemID": "activity-item-123",
	"body": "New contents",
	"incidentID": "incident-123"
});

if (!activityServiceResp.success) {
  // handle the error
  throw new Error(activityServiceResp.error);
}

// access the fields of the response
console.info({"activityItem", activityServiceResp.data.activityItem});

curl "https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/ActivityService.UpdateActivityEventTime" \
  --request POST \
  --header 'Content-Type: application/json; charset=utf-8' \
  --header 'Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...' \
  --data '{
	"activityItemID": "activity-item-123",
	"eventTime": "2021-08-07T11:58:23Z",
	"incidentID": "incident-123"
}'

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	incident "github.com/grafana/incident-go"
)

func main() {
	ctx := context.Background()
	// create a client, and required services...
	serviceAccountToken := os.Getenv("SERVICE_ACCOUNT_TOKEN")
	client := incident.NewClient("https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1", serviceAccountToken)
	activityService := incident.NewActivityService(client)
	// make the request...
	updateActivityEventTimeResp, err := activityService.UpdateActivityEventTime(ctx, main.UpdateActivityEventTimeRequest{
		IncidentID: "incident-123",
		ActivityItemID: "activity-item-123",
		EventTime: "2021-08-07T11:58:23Z",
	})
	if err != nil {
		// something went wrong
		fmt.Errorf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
	// use the output fields...
	log.Printf("ActivityItem: %+v\n", updateActivityEventTimeResp.ActivityItem)
	log.Printf("Error: %+v\n", updateActivityEventTimeResp.Error)

}

POST https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/ActivityService.UpdateActivityEventTime
Content-Type="application/json; charset=utf-8"
Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...

{
	"activityItemID": "activity-item-123",
	"eventTime": "2021-08-07T11:58:23Z",
	"incidentID": "incident-123"
}

import { GrafanaIncidentClient, ActivityService } from '@grafana/incident-node';

// https://grafana.com/docs/grafana-cloud/incident/api/auth/#get-a-service-account-token
const serviceAccountToken = process.env.GRAFANA_CLOUD_SERVICE_ACCOUNT_TOKEN;
const client = new GrafanaIncidentClient(
  "https://your-stack.grafana.net",
  serviceAccountToken
);
const activityService = new ActivityService(client);

// UpdateActivityEventTime updates the event time of a specific activity item.
const activityServiceResp = await activityService.updateActivityEventTime({
	"activityItemID": "activity-item-123",
	"eventTime": "2021-08-07T11:58:23Z",
	"incidentID": "incident-123"
});

if (!activityServiceResp.success) {
  // handle the error
  throw new Error(activityServiceResp.error);
}

// access the fields of the response
console.info({"activityItem", activityServiceResp.data.activityItem});

curl "https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/IncidentsService.AddLabel" \
  --request POST \
  --header 'Content-Type: application/json; charset=utf-8' \
  --header 'Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...' \
  --data '{
	"incidentID": "incident-123",
	"label": {
		"colorHex": "#ff0000",
		"description": "Customers are affected by this incident.",
		"label": "customers-affected"
	}
}'

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	incident "github.com/grafana/incident-go"
)

func main() {
	ctx := context.Background()
	// create a client, and required services...
	serviceAccountToken := os.Getenv("SERVICE_ACCOUNT_TOKEN")
	client := incident.NewClient("https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1", serviceAccountToken)
	incidentsService := incident.NewIncidentsService(client)
	// make the request...
	addLabelResp, err := incidentsService.AddLabel(ctx, main.AddLabelRequest{
		IncidentID: "incident-123",
		Label: main.IncidentLabel{
			Label: "customers-affected",
			Description: "Customers are affected by this incident.",
			ColorHex: "#ff0000",
		},
	})
	if err != nil {
		// something went wrong
		fmt.Errorf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
	// use the output fields...
	log.Printf("Incident: %+v\n", addLabelResp.Incident)
	log.Printf("Error: %+v\n", addLabelResp.Error)

}

POST https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/IncidentsService.AddLabel
Content-Type="application/json; charset=utf-8"
Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...

{
	"incidentID": "incident-123",
	"label": {
		"colorHex": "#ff0000",
		"description": "Customers are affected by this incident.",
		"label": "customers-affected"
	}
}

import { GrafanaIncidentClient, IncidentsService } from '@grafana/incident-node';

// https://grafana.com/docs/grafana-cloud/incident/api/auth/#get-a-service-account-token
const serviceAccountToken = process.env.GRAFANA_CLOUD_SERVICE_ACCOUNT_TOKEN;
const client = new GrafanaIncidentClient(
  "https://your-stack.grafana.net",
  serviceAccountToken
);
const incidentsService = new IncidentsService(client);

// AddLabel adds a label to the Incident.
const incidentsServiceResp = await incidentsService.addLabel({
	"incidentID": "incident-123",
	"label": {
		"colorHex": "#ff0000",
		"description": "Customers are affected by this incident.",
		"label": "customers-affected"
	}
});

if (!incidentsServiceResp.success) {
  // handle the error
  throw new Error(incidentsServiceResp.error);
}

// access the fields of the response
console.info({"incident", incidentsServiceResp.data.incident});

curl "https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/IncidentsService.AssignRole" \
  --request POST \
  --header 'Content-Type: application/json; charset=utf-8' \
  --header 'Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...' \
  --data '{
	"incidentID": "incident-123",
	"role": "commander",
	"userID": "grafana-incident:user-123"
}'

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	incident "github.com/grafana/incident-go"
)

func main() {
	ctx := context.Background()
	// create a client, and required services...
	serviceAccountToken := os.Getenv("SERVICE_ACCOUNT_TOKEN")
	client := incident.NewClient("https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1", serviceAccountToken)
	incidentsService := incident.NewIncidentsService(client)
	// make the request...
	assignRoleResp, err := incidentsService.AssignRole(ctx, main.AssignRoleRequest{
		IncidentID: "incident-123",
		UserID: "grafana-incident:user-123",
		Role: "commander",
	})
	if err != nil {
		// something went wrong
		fmt.Errorf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
	// use the output fields...
	log.Printf("Incident: %+v\n", assignRoleResp.Incident)
	log.Printf("DidChange: %+v\n", assignRoleResp.DidChange)
	log.Printf("Error: %+v\n", assignRoleResp.Error)

}

POST https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/IncidentsService.AssignRole
Content-Type="application/json; charset=utf-8"
Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...

{
	"incidentID": "incident-123",
	"role": "commander",
	"userID": "grafana-incident:user-123"
}

import { GrafanaIncidentClient, IncidentsService } from '@grafana/incident-node';

// https://grafana.com/docs/grafana-cloud/incident/api/auth/#get-a-service-account-token
const serviceAccountToken = process.env.GRAFANA_CLOUD_SERVICE_ACCOUNT_TOKEN;
const client = new GrafanaIncidentClient(
  "https://your-stack.grafana.net",
  serviceAccountToken
);
const incidentsService = new IncidentsService(client);

// AssignRole assigns a role to a user.
const incidentsServiceResp = await incidentsService.assignRole({
	"incidentID": "incident-123",
	"role": "commander",
	"userID": "grafana-incident:user-123"
});

if (!incidentsServiceResp.success) {
  // handle the error
  throw new Error(incidentsServiceResp.error);
}

// access the fields of the response
console.info({"incident", incidentsServiceResp.data.incident});
console.info({"didChange", incidentsServiceResp.data.didChange});

curl "https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/IncidentsService.CreateIncident" \
  --request POST \
  --header 'Content-Type: application/json; charset=utf-8' \
  --header 'Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...' \
  --data '{
	"attachCaption": "Grafana Incident: Powerful incident management, built on top of Grafana",
	"attachURL": "https://grafana.com/products/incident",
	"isDrill": true,
	"labels": [
		{
			"colorHex": "#ff0000",
			"description": "Customers are affected by this incident.",
			"label": "customers-affected"
		},
		{
			"colorHex": "#ff0000",
			"description": "Customers are affected by this incident.",
			"label": "customers-affected"
		}
	],
	"roomPrefix": "incident",
	"severity": "minor",
	"status": "active",
	"title": "High latency in web requests"
}'

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	incident "github.com/grafana/incident-go"
)

func main() {
	ctx := context.Background()
	// create a client, and required services...
	serviceAccountToken := os.Getenv("SERVICE_ACCOUNT_TOKEN")
	client := incident.NewClient("https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1", serviceAccountToken)
	incidentsService := incident.NewIncidentsService(client)
	// make the request...
	createIncidentResp, err := incidentsService.CreateIncident(ctx, main.CreateIncidentRequest{
		Title: "High latency in web requests",
		Severity: "minor",
		Labels: main.IncidentLabel{
			Label: "customers-affected",
			Description: "Customers are affected by this incident.",
			ColorHex: "#ff0000",
		},
		RoomPrefix: "incident",
		IsDrill: true,
		Status: "active",
		AttachCaption: "Grafana Incident: Powerful incident management, built on top of Grafana",
		AttachURL: "https://grafana.com/products/incident",
	})
	if err != nil {
		// something went wrong
		fmt.Errorf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
	// use the output fields...
	log.Printf("Incident: %+v\n", createIncidentResp.Incident)
	log.Printf("Error: %+v\n", createIncidentResp.Error)

}

POST https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/IncidentsService.CreateIncident
Content-Type="application/json; charset=utf-8"
Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...

{
	"attachCaption": "Grafana Incident: Powerful incident management, built on top of Grafana",
	"attachURL": "https://grafana.com/products/incident",
	"isDrill": true,
	"labels": [
		{
			"colorHex": "#ff0000",
			"description": "Customers are affected by this incident.",
			"label": "customers-affected"
		},
		{
			"colorHex": "#ff0000",
			"description": "Customers are affected by this incident.",
			"label": "customers-affected"
		}
	],
	"roomPrefix": "incident",
	"severity": "minor",
	"status": "active",
	"title": "High latency in web requests"
}

import { GrafanaIncidentClient, IncidentsService } from '@grafana/incident-node';

// https://grafana.com/docs/grafana-cloud/incident/api/auth/#get-a-service-account-token
const serviceAccountToken = process.env.GRAFANA_CLOUD_SERVICE_ACCOUNT_TOKEN;
const client = new GrafanaIncidentClient(
  "https://your-stack.grafana.net",
  serviceAccountToken
);
const incidentsService = new IncidentsService(client);

// CreateIncident creates a new Incident.
const incidentsServiceResp = await incidentsService.createIncident({
	"attachCaption": "Grafana Incident: Powerful incident management, built on top of Grafana",
	"attachURL": "https://grafana.com/products/incident",
	"isDrill": true,
	"labels": [
		{
			"colorHex": "#ff0000",
			"description": "Customers are affected by this incident.",
			"label": "customers-affected"
		},
		{
			"colorHex": "#ff0000",
			"description": "Customers are affected by this incident.",
			"label": "customers-affected"
		}
	],
	"roomPrefix": "incident",
	"severity": "minor",
	"status": "active",
	"title": "High latency in web requests"
});

if (!incidentsServiceResp.success) {
  // handle the error
  throw new Error(incidentsServiceResp.error);
}

// access the fields of the response
console.info({"incident", incidentsServiceResp.data.incident});

curl "https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/IncidentsService.GetIncident" \
  --request POST \
  --header 'Content-Type: application/json; charset=utf-8' \
  --header 'Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...' \
  --data '{
	"incidentID": "incident-123"
}'

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	incident "github.com/grafana/incident-go"
)

func main() {
	ctx := context.Background()
	// create a client, and required services...
	serviceAccountToken := os.Getenv("SERVICE_ACCOUNT_TOKEN")
	client := incident.NewClient("https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1", serviceAccountToken)
	incidentsService := incident.NewIncidentsService(client)
	// make the request...
	getIncidentResp, err := incidentsService.GetIncident(ctx, main.GetIncidentRequest{
		IncidentID: "incident-123",
	})
	if err != nil {
		// something went wrong
		fmt.Errorf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
	// use the output fields...
	log.Printf("Incident: %+v\n", getIncidentResp.Incident)
	log.Printf("Error: %+v\n", getIncidentResp.Error)

}

POST https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/IncidentsService.GetIncident
Content-Type="application/json; charset=utf-8"
Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...

{
	"incidentID": "incident-123"
}

import { GrafanaIncidentClient, IncidentsService } from '@grafana/incident-node';

// https://grafana.com/docs/grafana-cloud/incident/api/auth/#get-a-service-account-token
const serviceAccountToken = process.env.GRAFANA_CLOUD_SERVICE_ACCOUNT_TOKEN;
const client = new GrafanaIncidentClient(
  "https://your-stack.grafana.net",
  serviceAccountToken
);
const incidentsService = new IncidentsService(client);

// GetIncident gets an existing Incident by ID.
const incidentsServiceResp = await incidentsService.getIncident({
	"incidentID": "incident-123"
});

if (!incidentsServiceResp.success) {
  // handle the error
  throw new Error(incidentsServiceResp.error);
}

// access the fields of the response
console.info({"incident", incidentsServiceResp.data.incident});

curl "https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/IncidentsService.GetIncidentMembership" \
  --request POST \
  --header 'Content-Type: application/json; charset=utf-8' \
  --header 'Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...' \
  --data '{
	"incidentID": "1"
}'

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	incident "github.com/grafana/incident-go"
)

func main() {
	ctx := context.Background()
	// create a client, and required services...
	serviceAccountToken := os.Getenv("SERVICE_ACCOUNT_TOKEN")
	client := incident.NewClient("https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1", serviceAccountToken)
	incidentsService := incident.NewIncidentsService(client)
	// make the request...
	getIncidentMembershipResp, err := incidentsService.GetIncidentMembership(ctx, main.GetIncidentMembershipRequest{
		IncidentID: "1",
	})
	if err != nil {
		// something went wrong
		fmt.Errorf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
	// use the output fields...
	log.Printf("Assignments: %+v\n", getIncidentMembershipResp.Assignments)
	log.Printf("Error: %+v\n", getIncidentMembershipResp.Error)

}

POST https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/IncidentsService.GetIncidentMembership
Content-Type="application/json; charset=utf-8"
Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...

{
	"incidentID": "1"
}

import { GrafanaIncidentClient, IncidentsService } from '@grafana/incident-node';

// https://grafana.com/docs/grafana-cloud/incident/api/auth/#get-a-service-account-token
const serviceAccountToken = process.env.GRAFANA_CLOUD_SERVICE_ACCOUNT_TOKEN;
const client = new GrafanaIncidentClient(
  "https://your-stack.grafana.net",
  serviceAccountToken
);
const incidentsService = new IncidentsService(client);

// GetIncidentMembership will return the full list of people involved in an incident
const incidentsServiceResp = await incidentsService.getIncidentMembership({
	"incidentID": "1"
});

if (!incidentsServiceResp.success) {
  // handle the error
  throw new Error(incidentsServiceResp.error);
}

// access the fields of the response
console.info({"assignments", incidentsServiceResp.data.assignments});

curl "https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/IncidentsService.QueryIncidents" \
  --request POST \
  --header 'Content-Type: application/json; charset=utf-8' \
  --header 'Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...' \
  --data '{
	"cursor": {
		"hasMore": true,
		"nextValue": "aaaabbbbccccddddeeeeffffgggg"
	},
	"query": {
		"dateFrom": "2021-01-01T02:07:14+00:00",
		"dateTo": "2021-01-01T02:07:14+00:00",
		"excludeStatuses": [
			"closed"
		],
		"incidentLabels": [
			"security",
			"customersaffected"
		],
		"includeStatuses": [
			"active"
		],
		"limit": 10,
		"onlyDrills": true,
		"orderDirection": "ASC",
		"queryString": "isdrill:false any(label:security label:important)",
		"severity": "major"
	}
}'

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	incident "github.com/grafana/incident-go"
)

func main() {
	ctx := context.Background()
	// create a client, and required services...
	serviceAccountToken := os.Getenv("SERVICE_ACCOUNT_TOKEN")
	client := incident.NewClient("https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1", serviceAccountToken)
	incidentsService := incident.NewIncidentsService(client)
	// make the request...
	queryIncidentsResp, err := incidentsService.QueryIncidents(ctx, main.QueryIncidentsRequest{
		Query: main.IncidentsQuery{
			Limit: 10,
			IncludeStatuses: ["active"],
			ExcludeStatuses: ["closed"],
			IncidentLabels: ["security","customersaffected"],
			DateFrom: "2021-01-01T02:07:14+00:00",
			DateTo: "2021-01-01T02:07:14+00:00",
			OnlyDrills: true,
			OrderDirection: "ASC",
			Severity: "major",
			QueryString: "isdrill:false any(label:security label:important)",
		},
		Cursor: main.Cursor{
			NextValue: "aaaabbbbccccddddeeeeffffgggg",
			HasMore: true,
		},
	})
	if err != nil {
		// something went wrong
		fmt.Errorf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
	// use the output fields...
	log.Printf("Incidents: %+v\n", queryIncidentsResp.Incidents)
	log.Printf("Query: %+v\n", queryIncidentsResp.Query)
	log.Printf("Cursor: %+v\n", queryIncidentsResp.Cursor)
	log.Printf("Error: %+v\n", queryIncidentsResp.Error)

}

POST https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/IncidentsService.QueryIncidents
Content-Type="application/json; charset=utf-8"
Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...

{
	"cursor": {
		"hasMore": true,
		"nextValue": "aaaabbbbccccddddeeeeffffgggg"
	},
	"query": {
		"dateFrom": "2021-01-01T02:07:14+00:00",
		"dateTo": "2021-01-01T02:07:14+00:00",
		"excludeStatuses": [
			"closed"
		],
		"incidentLabels": [
			"security",
			"customersaffected"
		],
		"includeStatuses": [
			"active"
		],
		"limit": 10,
		"onlyDrills": true,
		"orderDirection": "ASC",
		"queryString": "isdrill:false any(label:security label:important)",
		"severity": "major"
	}
}

import { GrafanaIncidentClient, IncidentsService } from '@grafana/incident-node';

// https://grafana.com/docs/grafana-cloud/incident/api/auth/#get-a-service-account-token
const serviceAccountToken = process.env.GRAFANA_CLOUD_SERVICE_ACCOUNT_TOKEN;
const client = new GrafanaIncidentClient(
  "https://your-stack.grafana.net",
  serviceAccountToken
);
const incidentsService = new IncidentsService(client);

// QueryIncidents gets a list of Incidents.
const incidentsServiceResp = await incidentsService.queryIncidents({
	"cursor": {
		"hasMore": true,
		"nextValue": "aaaabbbbccccddddeeeeffffgggg"
	},
	"query": {
		"dateFrom": "2021-01-01T02:07:14+00:00",
		"dateTo": "2021-01-01T02:07:14+00:00",
		"excludeStatuses": [
			"closed"
		],
		"incidentLabels": [
			"security",
			"customersaffected"
		],
		"includeStatuses": [
			"active"
		],
		"limit": 10,
		"onlyDrills": true,
		"orderDirection": "ASC",
		"queryString": "isdrill:false any(label:security label:important)",
		"severity": "major"
	}
});

if (!incidentsServiceResp.success) {
  // handle the error
  throw new Error(incidentsServiceResp.error);
}

// access the fields of the response
console.info({"incidents", incidentsServiceResp.data.incidents});
console.info({"query", incidentsServiceResp.data.query});
console.info({"cursor", incidentsServiceResp.data.cursor});

curl "https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/IncidentsService.RemoveLabel" \
  --request POST \
  --header 'Content-Type: application/json; charset=utf-8' \
  --header 'Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...' \
  --data '{
	"incidentID": "incident-123",
	"label": "customers-affected"
}'

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	incident "github.com/grafana/incident-go"
)

func main() {
	ctx := context.Background()
	// create a client, and required services...
	serviceAccountToken := os.Getenv("SERVICE_ACCOUNT_TOKEN")
	client := incident.NewClient("https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1", serviceAccountToken)
	incidentsService := incident.NewIncidentsService(client)
	// make the request...
	removeLabelResp, err := incidentsService.RemoveLabel(ctx, main.RemoveLabelRequest{
		IncidentID: "incident-123",
		Label: "customers-affected",
	})
	if err != nil {
		// something went wrong
		fmt.Errorf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
	// use the output fields...
	log.Printf("Incident: %+v\n", removeLabelResp.Incident)
	log.Printf("Error: %+v\n", removeLabelResp.Error)

}

POST https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/IncidentsService.RemoveLabel
Content-Type="application/json; charset=utf-8"
Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...

{
	"incidentID": "incident-123",
	"label": "customers-affected"
}

import { GrafanaIncidentClient, IncidentsService } from '@grafana/incident-node';

// https://grafana.com/docs/grafana-cloud/incident/api/auth/#get-a-service-account-token
const serviceAccountToken = process.env.GRAFANA_CLOUD_SERVICE_ACCOUNT_TOKEN;
const client = new GrafanaIncidentClient(
  "https://your-stack.grafana.net",
  serviceAccountToken
);
const incidentsService = new IncidentsService(client);

// RemoveLabel removes a label from the Incident.
const incidentsServiceResp = await incidentsService.removeLabel({
	"incidentID": "incident-123",
	"label": "customers-affected"
});

if (!incidentsServiceResp.success) {
  // handle the error
  throw new Error(incidentsServiceResp.error);
}

// access the fields of the response
console.info({"incident", incidentsServiceResp.data.incident});

curl "https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/IncidentsService.UnassignRole" \
  --request POST \
  --header 'Content-Type: application/json; charset=utf-8' \
  --header 'Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...' \
  --data '{
	"incidentID": "incident-123",
	"role": "commander",
	"userID": "grafana-incident:user-123"
}'

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	incident "github.com/grafana/incident-go"
)

func main() {
	ctx := context.Background()
	// create a client, and required services...
	serviceAccountToken := os.Getenv("SERVICE_ACCOUNT_TOKEN")
	client := incident.NewClient("https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1", serviceAccountToken)
	incidentsService := incident.NewIncidentsService(client)
	// make the request...
	unassignRoleResp, err := incidentsService.UnassignRole(ctx, main.UnassignRoleRequest{
		IncidentID: "incident-123",
		UserID: "grafana-incident:user-123",
		Role: "commander",
	})
	if err != nil {
		// something went wrong
		fmt.Errorf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
	// use the output fields...
	log.Printf("Incident: %+v\n", unassignRoleResp.Incident)
	log.Printf("DidChange: %+v\n", unassignRoleResp.DidChange)
	log.Printf("Error: %+v\n", unassignRoleResp.Error)

}

POST https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/IncidentsService.UnassignRole
Content-Type="application/json; charset=utf-8"
Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...

{
	"incidentID": "incident-123",
	"role": "commander",
	"userID": "grafana-incident:user-123"
}

import { GrafanaIncidentClient, IncidentsService } from '@grafana/incident-node';

// https://grafana.com/docs/grafana-cloud/incident/api/auth/#get-a-service-account-token
const serviceAccountToken = process.env.GRAFANA_CLOUD_SERVICE_ACCOUNT_TOKEN;
const client = new GrafanaIncidentClient(
  "https://your-stack.grafana.net",
  serviceAccountToken
);
const incidentsService = new IncidentsService(client);

// UnassignRole removes a role assignment from a user.
const incidentsServiceResp = await incidentsService.unassignRole({
	"incidentID": "incident-123",
	"role": "commander",
	"userID": "grafana-incident:user-123"
});

if (!incidentsServiceResp.success) {
  // handle the error
  throw new Error(incidentsServiceResp.error);
}

// access the fields of the response
console.info({"incident", incidentsServiceResp.data.incident});
console.info({"didChange", incidentsServiceResp.data.didChange});

curl "https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/IncidentsService.UpdateIncidentEventTime" \
  --request POST \
  --header 'Content-Type: application/json; charset=utf-8' \
  --header 'Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...' \
  --data '{
	"activityItemKind": "incidentEnd",
	"eventTime": "2022-02-11 00:50:20.574137",
	"incidentID": "1"
}'

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	incident "github.com/grafana/incident-go"
)

func main() {
	ctx := context.Background()
	// create a client, and required services...
	serviceAccountToken := os.Getenv("SERVICE_ACCOUNT_TOKEN")
	client := incident.NewClient("https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1", serviceAccountToken)
	incidentsService := incident.NewIncidentsService(client)
	// make the request...
	updateIncidentEventTimeResp, err := incidentsService.UpdateIncidentEventTime(ctx, main.UpdateIncidentEventTimeRequest{
		IncidentID: "1",
		EventTime: "2022-02-11 00:50:20.574137",
		ActivityItemKind: "incidentEnd",
	})
	if err != nil {
		// something went wrong
		fmt.Errorf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
	// use the output fields...
	log.Printf("Error: %+v\n", updateIncidentEventTimeResp.Error)

}

POST https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/IncidentsService.UpdateIncidentEventTime
Content-Type="application/json; charset=utf-8"
Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...

{
	"activityItemKind": "incidentEnd",
	"eventTime": "2022-02-11 00:50:20.574137",
	"incidentID": "1"
}

import { GrafanaIncidentClient, IncidentsService } from '@grafana/incident-node';

// https://grafana.com/docs/grafana-cloud/incident/api/auth/#get-a-service-account-token
const serviceAccountToken = process.env.GRAFANA_CLOUD_SERVICE_ACCOUNT_TOKEN;
const client = new GrafanaIncidentClient('https://your-stack.grafana.net', serviceAccountToken);
const incidentsService = new IncidentsService(client);

// UpdateIncidentEventTime updates the start or end times of an Incident.
const incidentsServiceResp = await incidentsService.updateIncidentEventTime({
  activityItemKind: 'incidentEnd',
  eventTime: '2022-02-11 00:50:20.574137',
  incidentID: '1',
});

if (!incidentsServiceResp.success) {
  // handle the error
  throw new Error(incidentsServiceResp.error);
}

// access the fields of the response

curl "https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/IncidentsService.UpdateIncidentIsDrill" \
  --request POST \
  --header 'Content-Type: application/json; charset=utf-8' \
  --header 'Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...' \
  --data '{
	"incidentID": "incident-123",
	"isDrill": true
}'

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	incident "github.com/grafana/incident-go"
)

func main() {
	ctx := context.Background()
	// create a client, and required services...
	serviceAccountToken := os.Getenv("SERVICE_ACCOUNT_TOKEN")
	client := incident.NewClient("https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1", serviceAccountToken)
	incidentsService := incident.NewIncidentsService(client)
	// make the request...
	updateIncidentIsDrillResp, err := incidentsService.UpdateIncidentIsDrill(ctx, main.UpdateIncidentIsDrillRequest{
		IncidentID: "incident-123",
		IsDrill: true,
	})
	if err != nil {
		// something went wrong
		fmt.Errorf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
	// use the output fields...
	log.Printf("Incident: %+v\n", updateIncidentIsDrillResp.Incident)
	log.Printf("Error: %+v\n", updateIncidentIsDrillResp.Error)

}

POST https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/IncidentsService.UpdateIncidentIsDrill
Content-Type="application/json; charset=utf-8"
Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...

{
	"incidentID": "incident-123",
	"isDrill": true
}

import { GrafanaIncidentClient, IncidentsService } from '@grafana/incident-node';

// https://grafana.com/docs/grafana-cloud/incident/api/auth/#get-a-service-account-token
const serviceAccountToken = process.env.GRAFANA_CLOUD_SERVICE_ACCOUNT_TOKEN;
const client = new GrafanaIncidentClient(
  "https://your-stack.grafana.net",
  serviceAccountToken
);
const incidentsService = new IncidentsService(client);

// UpdateIncidentIsDrill changes whether an Incident is a drill or not.
const incidentsServiceResp = await incidentsService.updateIncidentIsDrill({
	"incidentID": "incident-123",
	"isDrill": true
});

if (!incidentsServiceResp.success) {
  // handle the error
  throw new Error(incidentsServiceResp.error);
}

// access the fields of the response
console.info({"incident", incidentsServiceResp.data.incident});

curl "https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/IncidentsService.UpdateSeverity" \
  --request POST \
  --header 'Content-Type: application/json; charset=utf-8' \
  --header 'Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...' \
  --data '{
	"incidentID": "incident-123",
	"severity": "minor"
}'

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	incident "github.com/grafana/incident-go"
)

func main() {
	ctx := context.Background()
	// create a client, and required services...
	serviceAccountToken := os.Getenv("SERVICE_ACCOUNT_TOKEN")
	client := incident.NewClient("https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1", serviceAccountToken)
	incidentsService := incident.NewIncidentsService(client)
	// make the request...
	updateSeverityResp, err := incidentsService.UpdateSeverity(ctx, main.UpdateSeverityRequest{
		IncidentID: "incident-123",
		Severity: "minor",
	})
	if err != nil {
		// something went wrong
		fmt.Errorf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
	// use the output fields...
	log.Printf("Incident: %+v\n", updateSeverityResp.Incident)
	log.Printf("Error: %+v\n", updateSeverityResp.Error)

}

POST https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/IncidentsService.UpdateSeverity
Content-Type="application/json; charset=utf-8"
Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...

{
	"incidentID": "incident-123",
	"severity": "minor"
}

import { GrafanaIncidentClient, IncidentsService } from '@grafana/incident-node';

// https://grafana.com/docs/grafana-cloud/incident/api/auth/#get-a-service-account-token
const serviceAccountToken = process.env.GRAFANA_CLOUD_SERVICE_ACCOUNT_TOKEN;
const client = new GrafanaIncidentClient(
  "https://your-stack.grafana.net",
  serviceAccountToken
);
const incidentsService = new IncidentsService(client);

// UpdateSeverity updates the severity of an Incident.
const incidentsServiceResp = await incidentsService.updateSeverity({
	"incidentID": "incident-123",
	"severity": "minor"
});

if (!incidentsServiceResp.success) {
  // handle the error
  throw new Error(incidentsServiceResp.error);
}

// access the fields of the response
console.info({"incident", incidentsServiceResp.data.incident});

curl "https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/IncidentsService.UpdateStatus" \
  --request POST \
  --header 'Content-Type: application/json; charset=utf-8' \
  --header 'Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...' \
  --data '{
	"incidentID": "incident-123",
	"status": "resolved"
}'

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	incident "github.com/grafana/incident-go"
)

func main() {
	ctx := context.Background()
	// create a client, and required services...
	serviceAccountToken := os.Getenv("SERVICE_ACCOUNT_TOKEN")
	client := incident.NewClient("https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1", serviceAccountToken)
	incidentsService := incident.NewIncidentsService(client)
	// make the request...
	updateStatusResp, err := incidentsService.UpdateStatus(ctx, main.UpdateStatusRequest{
		IncidentID: "incident-123",
		Status: "resolved",
	})
	if err != nil {
		// something went wrong
		fmt.Errorf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
	// use the output fields...
	log.Printf("Incident: %+v\n", updateStatusResp.Incident)
	log.Printf("Error: %+v\n", updateStatusResp.Error)

}

POST https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/IncidentsService.UpdateStatus
Content-Type="application/json; charset=utf-8"
Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...

{
	"incidentID": "incident-123",
	"status": "resolved"
}

import { GrafanaIncidentClient, IncidentsService } from '@grafana/incident-node';

// https://grafana.com/docs/grafana-cloud/incident/api/auth/#get-a-service-account-token
const serviceAccountToken = process.env.GRAFANA_CLOUD_SERVICE_ACCOUNT_TOKEN;
const client = new GrafanaIncidentClient(
  "https://your-stack.grafana.net",
  serviceAccountToken
);
const incidentsService = new IncidentsService(client);

// UpdateStatus updates the status of an Incident.
const incidentsServiceResp = await incidentsService.updateStatus({
	"incidentID": "incident-123",
	"status": "resolved"
});

if (!incidentsServiceResp.success) {
  // handle the error
  throw new Error(incidentsServiceResp.error);
}

// access the fields of the response
console.info({"incident", incidentsServiceResp.data.incident});

curl "https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/IncidentsService.UpdateTitle" \
  --request POST \
  --header 'Content-Type: application/json; charset=utf-8' \
  --header 'Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...' \
  --data '{
	"incidentID": "incident-123",
	"title": "High latency in web requests"
}'

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	incident "github.com/grafana/incident-go"
)

func main() {
	ctx := context.Background()
	// create a client, and required services...
	serviceAccountToken := os.Getenv("SERVICE_ACCOUNT_TOKEN")
	client := incident.NewClient("https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1", serviceAccountToken)
	incidentsService := incident.NewIncidentsService(client)
	// make the request...
	updateTitleResp, err := incidentsService.UpdateTitle(ctx, main.UpdateTitleRequest{
		IncidentID: "incident-123",
		Title: "High latency in web requests",
	})
	if err != nil {
		// something went wrong
		fmt.Errorf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
	// use the output fields...
	log.Printf("Incident: %+v\n", updateTitleResp.Incident)
	log.Printf("Error: %+v\n", updateTitleResp.Error)

}

POST https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/IncidentsService.UpdateTitle
Content-Type="application/json; charset=utf-8"
Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...

{
	"incidentID": "incident-123",
	"title": "High latency in web requests"
}

import { GrafanaIncidentClient, IncidentsService } from '@grafana/incident-node';

// https://grafana.com/docs/grafana-cloud/incident/api/auth/#get-a-service-account-token
const serviceAccountToken = process.env.GRAFANA_CLOUD_SERVICE_ACCOUNT_TOKEN;
const client = new GrafanaIncidentClient(
  "https://your-stack.grafana.net",
  serviceAccountToken
);
const incidentsService = new IncidentsService(client);

// UpdateTitle updates the title of an Incident.
const incidentsServiceResp = await incidentsService.updateTitle({
	"incidentID": "incident-123",
	"title": "High latency in web requests"
});

if (!incidentsServiceResp.success) {
  // handle the error
  throw new Error(incidentsServiceResp.error);
}

// access the fields of the response
console.info({"incident", incidentsServiceResp.data.incident});

curl "https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/RolesService.ArchiveRole" \
  --request POST \
  --header 'Content-Type: application/json; charset=utf-8' \
  --header 'Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...' \
  --data '{
	"roleID": 1
}'

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	incident "github.com/grafana/incident-go"
)

func main() {
	ctx := context.Background()
	// create a client, and required services...
	serviceAccountToken := os.Getenv("SERVICE_ACCOUNT_TOKEN")
	client := incident.NewClient("https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1", serviceAccountToken)
	rolesService := incident.NewRolesService(client)
	// make the request...
	archiveRoleResp, err := rolesService.ArchiveRole(ctx, main.ArchiveRoleRequest{
		RoleID: 1,
	})
	if err != nil {
		// something went wrong
		fmt.Errorf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
	// use the output fields...
	log.Printf("Error: %+v\n", archiveRoleResp.Error)

}

POST https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/RolesService.ArchiveRole
Content-Type="application/json; charset=utf-8"
Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...

{
	"roleID": 1
}

import { GrafanaIncidentClient, RolesService } from '@grafana/incident-node';

// https://grafana.com/docs/grafana-cloud/incident/api/auth/#get-a-service-account-token
const serviceAccountToken = process.env.GRAFANA_CLOUD_SERVICE_ACCOUNT_TOKEN;
const client = new GrafanaIncidentClient('https://your-stack.grafana.net', serviceAccountToken);
const rolesService = new RolesService(client);

// ArchiveRole archives a role.
const rolesServiceResp = await rolesService.archiveRole({
  roleID: 1,
});

if (!rolesServiceResp.success) {
  // handle the error
  throw new Error(rolesServiceResp.error);
}

// access the fields of the response

curl "https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/RolesService.CreateRole" \
  --request POST \
  --header 'Content-Type: application/json; charset=utf-8' \
  --header 'Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...' \
  --data '{
	"role": {
		"archived": true,
		"createdAt": "2020-01-01T00:00:00Z",
		"description": "The commander is the incident commander.",
		"important": true,
		"mandatory": true,
		"name": "commander",
		"orgID": "org-1",
		"roleID": 1,
		"updatedAt": "2020-01-01T00:00:00Z"
	}
}'

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	incident "github.com/grafana/incident-go"
)

func main() {
	ctx := context.Background()
	// create a client, and required services...
	serviceAccountToken := os.Getenv("SERVICE_ACCOUNT_TOKEN")
	client := incident.NewClient("https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1", serviceAccountToken)
	rolesService := incident.NewRolesService(client)
	// make the request...
	createRoleResp, err := rolesService.CreateRole(ctx, main.CreateRoleRequest{
		Role: main.Role{
			RoleID: 1,
			OrgID: "org-1",
			Name: "commander",
			Description: "The commander is the incident commander.",
			Important: true,
			Mandatory: true,
			Archived: true,
			CreatedAt: "2020-01-01T00:00:00Z",
			UpdatedAt: "2020-01-01T00:00:00Z",
		},
	})
	if err != nil {
		// something went wrong
		fmt.Errorf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
	// use the output fields...
	log.Printf("Role: %+v\n", createRoleResp.Role)
	log.Printf("Error: %+v\n", createRoleResp.Error)

}

POST https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/RolesService.CreateRole
Content-Type="application/json; charset=utf-8"
Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...

{
	"role": {
		"archived": true,
		"createdAt": "2020-01-01T00:00:00Z",
		"description": "The commander is the incident commander.",
		"important": true,
		"mandatory": true,
		"name": "commander",
		"orgID": "org-1",
		"roleID": 1,
		"updatedAt": "2020-01-01T00:00:00Z"
	}
}

import { GrafanaIncidentClient, RolesService } from '@grafana/incident-node';

// https://grafana.com/docs/grafana-cloud/incident/api/auth/#get-a-service-account-token
const serviceAccountToken = process.env.GRAFANA_CLOUD_SERVICE_ACCOUNT_TOKEN;
const client = new GrafanaIncidentClient(
  "https://your-stack.grafana.net",
  serviceAccountToken
);
const rolesService = new RolesService(client);

// CreateRole creates a role.
const rolesServiceResp = await rolesService.createRole({
	"role": {
		"archived": true,
		"createdAt": "2020-01-01T00:00:00Z",
		"description": "The commander is the incident commander.",
		"important": true,
		"mandatory": true,
		"name": "commander",
		"orgID": "org-1",
		"roleID": 1,
		"updatedAt": "2020-01-01T00:00:00Z"
	}
});

if (!rolesServiceResp.success) {
  // handle the error
  throw new Error(rolesServiceResp.error);
}

// access the fields of the response
console.info({"role", rolesServiceResp.data.role});

curl "https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/RolesService.DeleteRole" \
  --request POST \
  --header 'Content-Type: application/json; charset=utf-8' \
  --header 'Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...' \
  --data '{
	"roleID": 1
}'

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	incident "github.com/grafana/incident-go"
)

func main() {
	ctx := context.Background()
	// create a client, and required services...
	serviceAccountToken := os.Getenv("SERVICE_ACCOUNT_TOKEN")
	client := incident.NewClient("https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1", serviceAccountToken)
	rolesService := incident.NewRolesService(client)
	// make the request...
	deleteRoleResp, err := rolesService.DeleteRole(ctx, main.DeleteRoleRequest{
		RoleID: 1,
	})
	if err != nil {
		// something went wrong
		fmt.Errorf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
	// use the output fields...
	log.Printf("Error: %+v\n", deleteRoleResp.Error)

}

POST https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/RolesService.DeleteRole
Content-Type="application/json; charset=utf-8"
Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...

{
	"roleID": 1
}

import { GrafanaIncidentClient, RolesService } from '@grafana/incident-node';

// https://grafana.com/docs/grafana-cloud/incident/api/auth/#get-a-service-account-token
const serviceAccountToken = process.env.GRAFANA_CLOUD_SERVICE_ACCOUNT_TOKEN;
const client = new GrafanaIncidentClient('https://your-stack.grafana.net', serviceAccountToken);
const rolesService = new RolesService(client);

// DeleteRole deletes a role.
const rolesServiceResp = await rolesService.deleteRole({
  roleID: 1,
});

if (!rolesServiceResp.success) {
  // handle the error
  throw new Error(rolesServiceResp.error);
}

// access the fields of the response

curl "https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/RolesService.GetRoles" \
  --request POST \
  --header 'Content-Type: application/json; charset=utf-8' \
  --header 'Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...' \
  --data '{}'

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	incident "github.com/grafana/incident-go"
)

func main() {
	ctx := context.Background()
	// create a client, and required services...
	serviceAccountToken := os.Getenv("SERVICE_ACCOUNT_TOKEN")
	client := incident.NewClient("https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1", serviceAccountToken)
	rolesService := incident.NewRolesService(client)
	// make the request...
	getRolesResp, err := rolesService.GetRoles(ctx, main.GetRolesRequest{
	})
	if err != nil {
		// something went wrong
		fmt.Errorf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
	// use the output fields...
	log.Printf("Roles: %+v\n", getRolesResp.Roles)
	log.Printf("Error: %+v\n", getRolesResp.Error)

}

POST https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/RolesService.GetRoles
Content-Type="application/json; charset=utf-8"
Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...

{}

import { GrafanaIncidentClient, RolesService } from '@grafana/incident-node';

// https://grafana.com/docs/grafana-cloud/incident/api/auth/#get-a-service-account-token
const serviceAccountToken = process.env.GRAFANA_CLOUD_SERVICE_ACCOUNT_TOKEN;
const client = new GrafanaIncidentClient(
  "https://your-stack.grafana.net",
  serviceAccountToken
);
const rolesService = new RolesService(client);

// GetRoles gets all roles.
const rolesServiceResp = await rolesService.getRoles({});

if (!rolesServiceResp.success) {
  // handle the error
  throw new Error(rolesServiceResp.error);
}

// access the fields of the response
console.info({"roles", rolesServiceResp.data.roles});

curl "https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/RolesService.UnarchiveRole" \
  --request POST \
  --header 'Content-Type: application/json; charset=utf-8' \
  --header 'Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...' \
  --data '{
	"roleID": 1
}'

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	incident "github.com/grafana/incident-go"
)

func main() {
	ctx := context.Background()
	// create a client, and required services...
	serviceAccountToken := os.Getenv("SERVICE_ACCOUNT_TOKEN")
	client := incident.NewClient("https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1", serviceAccountToken)
	rolesService := incident.NewRolesService(client)
	// make the request...
	unarchiveRoleResp, err := rolesService.UnarchiveRole(ctx, main.UnarchiveRoleRequest{
		RoleID: 1,
	})
	if err != nil {
		// something went wrong
		fmt.Errorf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
	// use the output fields...
	log.Printf("Error: %+v\n", unarchiveRoleResp.Error)

}

POST https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/RolesService.UnarchiveRole
Content-Type="application/json; charset=utf-8"
Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...

{
	"roleID": 1
}

import { GrafanaIncidentClient, RolesService } from '@grafana/incident-node';

// https://grafana.com/docs/grafana-cloud/incident/api/auth/#get-a-service-account-token
const serviceAccountToken = process.env.GRAFANA_CLOUD_SERVICE_ACCOUNT_TOKEN;
const client = new GrafanaIncidentClient('https://your-stack.grafana.net', serviceAccountToken);
const rolesService = new RolesService(client);

// UnarchiveRole unarchives a role.
const rolesServiceResp = await rolesService.unarchiveRole({
  roleID: 1,
});

if (!rolesServiceResp.success) {
  // handle the error
  throw new Error(rolesServiceResp.error);
}

// access the fields of the response

curl "https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/RolesService.UpdateRole" \
  --request POST \
  --header 'Content-Type: application/json; charset=utf-8' \
  --header 'Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...' \
  --data '{
	"role": {
		"archived": true,
		"createdAt": "2020-01-01T00:00:00Z",
		"description": "The commander is the incident commander.",
		"important": true,
		"mandatory": true,
		"name": "commander",
		"orgID": "org-1",
		"roleID": 1,
		"updatedAt": "2020-01-01T00:00:00Z"
	}
}'

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	incident "github.com/grafana/incident-go"
)

func main() {
	ctx := context.Background()
	// create a client, and required services...
	serviceAccountToken := os.Getenv("SERVICE_ACCOUNT_TOKEN")
	client := incident.NewClient("https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1", serviceAccountToken)
	rolesService := incident.NewRolesService(client)
	// make the request...
	updateRoleResp, err := rolesService.UpdateRole(ctx, main.UpdateRoleRequest{
		Role: main.Role{
			RoleID: 1,
			OrgID: "org-1",
			Name: "commander",
			Description: "The commander is the incident commander.",
			Important: true,
			Mandatory: true,
			Archived: true,
			CreatedAt: "2020-01-01T00:00:00Z",
			UpdatedAt: "2020-01-01T00:00:00Z",
		},
	})
	if err != nil {
		// something went wrong
		fmt.Errorf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
	// use the output fields...
	log.Printf("Role: %+v\n", updateRoleResp.Role)
	log.Printf("Error: %+v\n", updateRoleResp.Error)

}

POST https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/RolesService.UpdateRole
Content-Type="application/json; charset=utf-8"
Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...

{
	"role": {
		"archived": true,
		"createdAt": "2020-01-01T00:00:00Z",
		"description": "The commander is the incident commander.",
		"important": true,
		"mandatory": true,
		"name": "commander",
		"orgID": "org-1",
		"roleID": 1,
		"updatedAt": "2020-01-01T00:00:00Z"
	}
}

import { GrafanaIncidentClient, RolesService } from '@grafana/incident-node';

// https://grafana.com/docs/grafana-cloud/incident/api/auth/#get-a-service-account-token
const serviceAccountToken = process.env.GRAFANA_CLOUD_SERVICE_ACCOUNT_TOKEN;
const client = new GrafanaIncidentClient(
  "https://your-stack.grafana.net",
  serviceAccountToken
);
const rolesService = new RolesService(client);

// UpdateRole updates a role.
const rolesServiceResp = await rolesService.updateRole({
	"role": {
		"archived": true,
		"createdAt": "2020-01-01T00:00:00Z",
		"description": "The commander is the incident commander.",
		"important": true,
		"mandatory": true,
		"name": "commander",
		"orgID": "org-1",
		"roleID": 1,
		"updatedAt": "2020-01-01T00:00:00Z"
	}
});

if (!rolesServiceResp.success) {
  // handle the error
  throw new Error(rolesServiceResp.error);
}

// access the fields of the response
console.info({"role", rolesServiceResp.data.role});

curl "https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/TasksService.AddTask" \
  --request POST \
  --header 'Content-Type: application/json; charset=utf-8' \
  --header 'Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...' \
  --data '{
	"assignToUserID": "User123",
	"incidentID": "incident-123456",
	"text": "Assign an investigator"
}'

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	incident "github.com/grafana/incident-go"
)

func main() {
	ctx := context.Background()
	// create a client, and required services...
	serviceAccountToken := os.Getenv("SERVICE_ACCOUNT_TOKEN")
	client := incident.NewClient("https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1", serviceAccountToken)
	tasksService := incident.NewTasksService(client)
	// make the request...
	addTaskResp, err := tasksService.AddTask(ctx, main.AddTaskRequest{
		IncidentID: "incident-123456",
		Text: "Assign an investigator",
		AssignToUserId: "User123",
	})
	if err != nil {
		// something went wrong
		fmt.Errorf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
	// use the output fields...
	log.Printf("IncidentID: %+v\n", addTaskResp.IncidentID)
	log.Printf("Task: %+v\n", addTaskResp.Task)
	log.Printf("TaskList: %+v\n", addTaskResp.TaskList)
	log.Printf("Error: %+v\n", addTaskResp.Error)

}

POST https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/TasksService.AddTask
Content-Type="application/json; charset=utf-8"
Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...

{
	"assignToUserID": "User123",
	"incidentID": "incident-123456",
	"text": "Assign an investigator"
}

import { GrafanaIncidentClient, TasksService } from '@grafana/incident-node';

// https://grafana.com/docs/grafana-cloud/incident/api/auth/#get-a-service-account-token
const serviceAccountToken = process.env.GRAFANA_CLOUD_SERVICE_ACCOUNT_TOKEN;
const client = new GrafanaIncidentClient(
  "https://your-stack.grafana.net",
  serviceAccountToken
);
const tasksService = new TasksService(client);

// AddTask adds a task to an Incident.
const tasksServiceResp = await tasksService.addTask({
	"assignToUserID": "User123",
	"incidentID": "incident-123456",
	"text": "Assign an investigator"
});

if (!tasksServiceResp.success) {
  // handle the error
  throw new Error(tasksServiceResp.error);
}

// access the fields of the response
console.info({"incidentID", tasksServiceResp.data.incidentID});
console.info({"task", tasksServiceResp.data.task});
console.info({"taskList", tasksServiceResp.data.taskList});

curl "https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/TasksService.DeleteTask" \
  --request POST \
  --header 'Content-Type: application/json; charset=utf-8' \
  --header 'Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...' \
  --data '{
	"incidentID": "inccident-123456",
	"taskID": "task-123456"
}'

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	incident "github.com/grafana/incident-go"
)

func main() {
	ctx := context.Background()
	// create a client, and required services...
	serviceAccountToken := os.Getenv("SERVICE_ACCOUNT_TOKEN")
	client := incident.NewClient("https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1", serviceAccountToken)
	tasksService := incident.NewTasksService(client)
	// make the request...
	deleteTaskResp, err := tasksService.DeleteTask(ctx, main.DeleteTaskRequest{
		IncidentID: "inccident-123456",
		TaskID: "task-123456",
	})
	if err != nil {
		// something went wrong
		fmt.Errorf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
	// use the output fields...
	log.Printf("IncidentID: %+v\n", deleteTaskResp.IncidentID)
	log.Printf("TaskList: %+v\n", deleteTaskResp.TaskList)
	log.Printf("Error: %+v\n", deleteTaskResp.Error)

}

POST https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/TasksService.DeleteTask
Content-Type="application/json; charset=utf-8"
Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...

{
	"incidentID": "inccident-123456",
	"taskID": "task-123456"
}

import { GrafanaIncidentClient, TasksService } from '@grafana/incident-node';

// https://grafana.com/docs/grafana-cloud/incident/api/auth/#get-a-service-account-token
const serviceAccountToken = process.env.GRAFANA_CLOUD_SERVICE_ACCOUNT_TOKEN;
const client = new GrafanaIncidentClient(
  "https://your-stack.grafana.net",
  serviceAccountToken
);
const tasksService = new TasksService(client);

// DeleteTask deletes a task.
const tasksServiceResp = await tasksService.deleteTask({
	"incidentID": "inccident-123456",
	"taskID": "task-123456"
});

if (!tasksServiceResp.success) {
  // handle the error
  throw new Error(tasksServiceResp.error);
}

// access the fields of the response
console.info({"incidentID", tasksServiceResp.data.incidentID});
console.info({"taskList", tasksServiceResp.data.taskList});

curl "https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/TasksService.UpdateTaskStatus" \
  --request POST \
  --header 'Content-Type: application/json; charset=utf-8' \
  --header 'Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...' \
  --data '{
	"incidentID": "incident-123456",
	"status": "todo",
	"taskID": "task-12345"
}'

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	incident "github.com/grafana/incident-go"
)

func main() {
	ctx := context.Background()
	// create a client, and required services...
	serviceAccountToken := os.Getenv("SERVICE_ACCOUNT_TOKEN")
	client := incident.NewClient("https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1", serviceAccountToken)
	tasksService := incident.NewTasksService(client)
	// make the request...
	updateTaskStatusResp, err := tasksService.UpdateTaskStatus(ctx, main.UpdateTaskStatusRequest{
		IncidentID: "incident-123456",
		TaskID: "task-12345",
		Status: "todo",
	})
	if err != nil {
		// something went wrong
		fmt.Errorf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
	// use the output fields...
	log.Printf("IncidentID: %+v\n", updateTaskStatusResp.IncidentID)
	log.Printf("Task: %+v\n", updateTaskStatusResp.Task)
	log.Printf("TaskList: %+v\n", updateTaskStatusResp.TaskList)
	log.Printf("Error: %+v\n", updateTaskStatusResp.Error)

}

POST https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/TasksService.UpdateTaskStatus
Content-Type="application/json; charset=utf-8"
Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...

{
	"incidentID": "incident-123456",
	"status": "todo",
	"taskID": "task-12345"
}

import { GrafanaIncidentClient, TasksService } from '@grafana/incident-node';

// https://grafana.com/docs/grafana-cloud/incident/api/auth/#get-a-service-account-token
const serviceAccountToken = process.env.GRAFANA_CLOUD_SERVICE_ACCOUNT_TOKEN;
const client = new GrafanaIncidentClient(
  "https://your-stack.grafana.net",
  serviceAccountToken
);
const tasksService = new TasksService(client);

// UpdateTaskStatus updates the task's Status.
const tasksServiceResp = await tasksService.updateTaskStatus({
	"incidentID": "incident-123456",
	"status": "todo",
	"taskID": "task-12345"
});

if (!tasksServiceResp.success) {
  // handle the error
  throw new Error(tasksServiceResp.error);
}

// access the fields of the response
console.info({"incidentID", tasksServiceResp.data.incidentID});
console.info({"task", tasksServiceResp.data.task});
console.info({"taskList", tasksServiceResp.data.taskList});

curl "https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/TasksService.UpdateTaskText" \
  --request POST \
  --header 'Content-Type: application/json; charset=utf-8' \
  --header 'Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...' \
  --data '{
	"incidentID": "incident-123456",
	"taskID": "task-123456",
	"text": "Check the logs"
}'

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	incident "github.com/grafana/incident-go"
)

func main() {
	ctx := context.Background()
	// create a client, and required services...
	serviceAccountToken := os.Getenv("SERVICE_ACCOUNT_TOKEN")
	client := incident.NewClient("https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1", serviceAccountToken)
	tasksService := incident.NewTasksService(client)
	// make the request...
	updateTaskTextResp, err := tasksService.UpdateTaskText(ctx, main.UpdateTaskTextRequest{
		IncidentID: "incident-123456",
		TaskID: "task-123456",
		Text: "Check the logs",
	})
	if err != nil {
		// something went wrong
		fmt.Errorf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
	// use the output fields...
	log.Printf("IncidentID: %+v\n", updateTaskTextResp.IncidentID)
	log.Printf("Task: %+v\n", updateTaskTextResp.Task)
	log.Printf("TaskList: %+v\n", updateTaskTextResp.TaskList)
	log.Printf("Error: %+v\n", updateTaskTextResp.Error)

}

POST https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/TasksService.UpdateTaskText
Content-Type="application/json; charset=utf-8"
Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...

{
	"incidentID": "incident-123456",
	"taskID": "task-123456",
	"text": "Check the logs"
}

import { GrafanaIncidentClient, TasksService } from '@grafana/incident-node';

// https://grafana.com/docs/grafana-cloud/incident/api/auth/#get-a-service-account-token
const serviceAccountToken = process.env.GRAFANA_CLOUD_SERVICE_ACCOUNT_TOKEN;
const client = new GrafanaIncidentClient(
  "https://your-stack.grafana.net",
  serviceAccountToken
);
const tasksService = new TasksService(client);

// UpdateTaskText updates the task's text.
const tasksServiceResp = await tasksService.updateTaskText({
	"incidentID": "incident-123456",
	"taskID": "task-123456",
	"text": "Check the logs"
});

if (!tasksServiceResp.success) {
  // handle the error
  throw new Error(tasksServiceResp.error);
}

// access the fields of the response
console.info({"incidentID", tasksServiceResp.data.incidentID});
console.info({"task", tasksServiceResp.data.task});
console.info({"taskList", tasksServiceResp.data.taskList});

curl "https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/TasksService.UpdateTaskUser" \
  --request POST \
  --header 'Content-Type: application/json; charset=utf-8' \
  --header 'Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...' \
  --data '{
	"incidentID": "incident-123456",
	"taskID": "task-12345",
	"userID": "user-id"
}'

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	incident "github.com/grafana/incident-go"
)

func main() {
	ctx := context.Background()
	// create a client, and required services...
	serviceAccountToken := os.Getenv("SERVICE_ACCOUNT_TOKEN")
	client := incident.NewClient("https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1", serviceAccountToken)
	tasksService := incident.NewTasksService(client)
	// make the request...
	updateTaskUserResp, err := tasksService.UpdateTaskUser(ctx, main.UpdateTaskUserRequest{
		IncidentID: "incident-123456",
		TaskID: "task-12345",
		UserID: "user-id",
	})
	if err != nil {
		// something went wrong
		fmt.Errorf(os.Stderr, "%s\n", err)
		os.Exit(1)
	}
	// use the output fields...
	log.Printf("IncidentID: %+v\n", updateTaskUserResp.IncidentID)
	log.Printf("Task: %+v\n", updateTaskUserResp.Task)
	log.Printf("TaskList: %+v\n", updateTaskUserResp.TaskList)
	log.Printf("Error: %+v\n", updateTaskUserResp.Error)

}

POST https://your-stack.grafana.net/api/plugins/grafana-incident-app/resources/api/v1/TasksService.UpdateTaskUser
Content-Type="application/json; charset=utf-8"
Authorization: Bearer glsa_HOruNAb7SOiCdshU9algkrq7F...

{
	"incidentID": "incident-123456",
	"taskID": "task-12345",
	"userID": "user-id"
}

import { GrafanaIncidentClient, TasksService } from '@grafana/incident-node';

// https://grafana.com/docs/grafana-cloud/incident/api/auth/#get-a-service-account-token
const serviceAccountToken = process.env.GRAFANA_CLOUD_SERVICE_ACCOUNT_TOKEN;
const client = new GrafanaIncidentClient(
  "https://your-stack.grafana.net",
  serviceAccountToken
);
const tasksService = new TasksService(client);

// UpdateTaskUser updates the task's assigned user.
Passing an empty user ID will clear the assigned user.
const tasksServiceResp = await tasksService.updateTaskUser({
	"incidentID": "incident-123456",
	"taskID": "task-12345",
	"userID": "user-id"
});

if (!tasksServiceResp.success) {
  // handle the error
  throw new Error(tasksServiceResp.error);
}

// access the fields of the response
console.info({"incidentID", tasksServiceResp.data.incidentID});
console.info({"task", tasksServiceResp.data.task});
console.info({"taskList", tasksServiceResp.data.taskList});