Serval

https://docs.serval.com
Admin
Serval is an AI-native IT service management (ITSM) platform that automates help desk ticketing and...
Tokens:68,356
Snippets:182
Trust Score:7.6
Update:1 year ago
Show doc for...
Tokens:
Raw
### Manual Installation - Linux Example

Source: https://docs.serval.com/sections/cli/installation

Provides an example of manually installing the Serval CLI on Linux by downloading the binary, extracting it, and moving it to the PATH.

```bash
# Download the latest release (replace VERSION with actual version)
wget https://github.com/ServalHQ/homebrew-serval/releases/download/VERSION/serval-linux-amd64.tar.gz
# Extract
tar -xzf serval-linux-amd64.tar.gz
# Move to PATH
sudo mv serval /usr/local/bin/
# Make executable
chmod +x /usr/local/bin/serval
```

--------------------------------

### Getting Help with Google Workspace Integration

Source: https://docs.serval.com/sections/integrations/google-workspace

Steps to take if integration issues persist after following the setup guide. This includes verifying setup steps, allowing time for propagation, and checking user privileges.

```APIDOC
If you continue to experience issues:
1. Verify all steps in the setup process are complete
2. Wait 10-15 minutes for Google services to propagate changes
3. Check that your default subject user has admin privileges in Google Workspace
```

--------------------------------

### Kandji API Setup and Configuration

Source: https://docs.serval.com/sections/integrations/kandji

Provides instructions on how to set up the Kandji API and obtain the necessary Tenant Slug for configuring the Serval integration. It references the Kandji API Setup Guide.

```APIDOC
Follow the steps provided by Kandji to create your API Token here: [Kandji API Setup Guide](https://support.kandji.io/kb/kandji-api#what-is-the-kandji-api)
Make sure to grab your **Tenant Slug** (the part of the URL before the `.kandji.io`) from the Kandji API Setup Guide. You will need this to configure the Kandji integration in Serval. (e.g., `acme` NOT `https://acme.kandji.io`)
```

--------------------------------

### Service Account Integration Setup - Create Google Cloud Project and Service Account

Source: https://docs.serval.com/sections/integrations/google-workspace

Step-by-step guide to creating a Google Cloud Project and a Service Account, which is necessary for the Service Account integration method with Google Workspace.

```APIDOC
Step 1: Create Google Cloud Project and Service Account
  1. Navigate to console.cloud.google.com and login
  2. Create a new project:
     * Click “Select Project” → “New Project”
     * Choose any name for your project

  1. Create a service account:
     * Navigate to “Credentials” → “Create Credentials” → “Service Account”
     * Name your service account and create it (other fields optional)
```

--------------------------------

### Verify Serval CLI Installation

Source: https://docs.serval.com/sections/cli/installation

Verifies that the Serval CLI has been installed correctly by checking its version.

```bash
serval version
```

--------------------------------

### Serval Slack Integration Guide

Source: https://docs.serval.com/sections/integrations/slack

This section details the steps to integrate Serval with a Slack channel to function as a help desk. It covers connecting the Serval app to a channel, configuring settings, and enabling direct messaging for private support interactions. It also explains the recommended 'Silent Mode' for initial setup and testing.

```APIDOC
Serval Slack Integration:

Connect a Channel (Recommended):
  1. Go to the desired Slack channel.
  2. Mention @serval.
  3. Click 'Add them' when prompted.
  4. Configure channel settings within the Serval app.

Enable Direct Messaging (Optional):
  1. Navigate to the Slack app in Serval.
  2. Access help desk configuration settings.
  3. Enable the 'Direct Messaging' option.

Recommended Setup:
  - Start with 'Silent Mode' to test without user notification.
  - Disable 'Silent Mode' to activate full help desk functionality.

Channel Configuration Modes:
  - Disabled Mode (Default):
    - Serval does nothing.
    - No tickets created, no responses.
  - Silent Mode:
    - Serval monitors and creates tickets.
    - No responses or acknowledgments in the channel.
    - Use @serval to toggle on for ticket resolution.
  - Help Desk Mode:
    - Full functionality: creates tickets, responds with ticket links, uses AI for resolution.
    - Provides a complete support experience.
```

--------------------------------

### Enable Fish Shell Completion for Serval CLI

Source: https://docs.serval.com/sections/cli/installation

Enables autocompletion for the Serval CLI in Fish by saving the completion script to the user's config directory.

```fish
serval completion fish > ~/.config/fish/completions/serval.fish
```

--------------------------------

### Fish Shell Completion

Source: https://docs.serval.com/sections/cli/installation

Installs Serval CLI shell completion for Fish. This command downloads the Fish completion script and places it in the appropriate directory, enabling tab completion for Serval commands in Fish environments.

```fish
mkdir -p ~/.config/fish/completions
serval completion fish > ~/.config/fish/completions/serval.fish
```

--------------------------------

### Bash Shell Completion

Source: https://docs.serval.com/sections/cli/installation

Installs Serval CLI shell completion for Bash. This command downloads the Bash completion script and sources it, enabling tab completion for Serval commands in Bash environments.

```bash
serval completion bash > ~/.serval-completion.sh
source ~/.serval-completion.sh
```

--------------------------------

### Managing Serval GitHub Access

Source: https://docs.serval.com/sections/integrations/github

Guidance on how to manage the Serval GitHub integration after the initial setup, including changing permission tiers and uninstalling the application.

```APIDOC
Change permission tier – Remove the existing GitHub App in GitHub Settings → Installed GitHub Apps, then repeat the connection flow with the other tier.
Uninstall – Remove the app in GitHub; Serval will mark the connection as Disconnected automatically.
```

--------------------------------

### Enable Bash Shell Completion for Serval CLI

Source: https://docs.serval.com/sections/cli/installation

Enables autocompletion for the Serval CLI in Bash by saving the completion script to the appropriate directory.

```bash
serval completion bash > /etc/bash_completion.d/serval
```

--------------------------------

### Version Control Best Practices with Git

Source: https://docs.serval.com/sections/cli/push-pull-configuration

Guides on integrating workflows with Git, including initialization, committing changes, using branches for development, and pushing to Serval after merging.

```bash
git init
cd EXA
git add .
git commit -m "Initial workflow commit"
```

```bash
git checkout -b update-onboarding-workflow
# Make changes
git commit -m "Add manager approval to onboarding"
# Review and merge in your VCS
# After merging, push to Serval
serval push EXA
```

--------------------------------

### Install Serval CLI with Homebrew (macOS)

Source: https://docs.serval.com/sections/cli/installation

Installs the Serval CLI on macOS using Homebrew. This is the recommended method for macOS users.

```bash
brew install --cask servalhq/serval/serval
```

--------------------------------

### PowerShell Shell Completion

Source: https://docs.serval.com/sections/cli/installation

Installs Serval CLI shell completion for PowerShell. This command pipes the completion script output to `Out-String` and then executes it using `Invoke-Expression` to enable tab completion for Serval commands in PowerShell.

```powershell
serval completion powershell | Out-String | Invoke-Expression
```

--------------------------------

### Enable Zsh Shell Completion for Serval CLI

Source: https://docs.serval.com/sections/cli/installation

Enables autocompletion for the Serval CLI in Zsh by saving the completion script to the fpath directory.

```zsh
serval completion zsh > "${fpath[1]}/_serval"
```

--------------------------------

### Serval GitHub Integration Steps

Source: https://docs.serval.com/sections/integrations/github

A step-by-step guide to connecting Serval with GitHub. This process involves authorizing the Serval application on GitHub and selecting the appropriate access level.

```APIDOC
1. In Serval → Applications, find GitHub and click Connect.
2. Choose the AI Engineer or Admin access level.
3. You are redirected to GitHub. Select the target organization.
4. Review permissions and (optionally) limit the app to specific repositories.
5. Click Install & Authorize.
6. If you are an Org Owner, you are returned to Serval and the integration shows Healthy.
7. If you are not an Org Owner, GitHub marks the installation pending. Serval displays an “Installation Pending” badge until an owner clicks Approve in GitHub ➜ Settings → Installed GitHub Apps.
```

--------------------------------

### cURL Example for Creating Approval Procedure

Source: https://docs.serval.com/api-reference/access-policy-api/create-approval-procedure

Example using cURL to send a POST request to create an approval procedure. It includes setting the Authorization header with a bearer token and the Content-Type to application/json, along with the request payload.

```bash
curl --request POST \
  --url https://public.api.serval.com/v1/teams/{team_id}/access-policies/{access_policy_id}/approval-procedure \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{ \
  "steps": [ \
    { \
      "id": "<string>", \
      "stepType": "APPROVAL_PROCEDURE_STEP_TYPE_UNSPECIFIED", \
      "specificUserIds": [ \
        "<string>" \
      ], \
      "servalGroupIds": [ \
        "<string>" \
      ], \
      "allowSelfApproval": true \
    } \
  ] \
}'
```

--------------------------------

### Create Notion Internal Integration

Source: https://docs.serval.com/sections/integrations/notion

Step-by-step guide to creating an internal integration in Notion for Serval. This includes configuring integration name, workspace, and capabilities, and obtaining the internal integration token.

```APIDOC
1. Navigate to https://www.notion.so/my-integrations
2. Click + New integration
3. Configure your integration:
   * Name : Enter “Serval Integration” or another descriptive name
   * Associated workspace : Select your workspace
   * Capabilities : Choose the permissions Serval needs:
     * Read content
     * Update content
     * Insert content (if creating new pages/blocks)
     * Read comments (optional)
     * Read user information (optional)
4. Click Submit to create the integration
5. Copy the Internal Integration Token (starts with `secret_`)
```

--------------------------------

### Jira Ticket Syncing Setup

Source: https://docs.serval.com/sections/integrations/jira

Instructions to enable enhanced ticket syncing between Serval and Jira. This involves configuring Jira's development mode and uploading the Serval Connect app URL.

```APIDOC
APIDOC:
  title: Jira Ticket Syncing Setup
  description: Steps to enable enhanced ticket syncing between Serval and Jira.
  steps:
    - description: Navigate to Jira's Universal Plugin Manager (UPM).
      details: Go to `https://[your-domain].atlassian.net/plugins/servlet/upm`
    - description: Access settings for user-installed apps.
      details: Click **Settings** under the User-installed apps section.
    - description: Enable development mode.
      details: Ensure **Enable development mode** is turned on and click **Apply**.
    - description: Upload the Serval Connect app.
      details: Click **Upload app**.
    - description: Provide the Serval Connect app URL.
      details: Enter `https://svflow-oauth.api.serval.com/jira-connect/atlassian-connect.json`
    - description: Connect the app.
      details: Click **Connect** to activate enhanced ticket syncing.
```

--------------------------------

### Serval Okta Configuration Steps

Source: https://docs.serval.com/sections/integrations/okta

This section outlines the configuration steps required within Serval to connect to Okta. It involves navigating to the applications section, connecting the Okta integration, and inputting specific details obtained from Okta.

```APIDOC
Serval Configuration:
  1. Navigate to `Applications` -> `Available` tab in Serval.
  2. Find the Okta integration and click `Connect`.
  3. Paste the JSON from the Okta setup into the `Client Secret` field.
  4. Instance ID: Use your Okta instance's domain (e.g., `mycompany.okta.com`). Exclude `-admin` if present (e.g., `mycompany-admin.okta.com` becomes `mycompany.okta.com`).
  5. Client ID: Found at the top of the Okta app integration page.
  6. Scopes: Enter a comma-separated list of granted permissions (e.g., `okta.apps.read,okta.apps.manage,okta.users.read,okta.users.manage,okta.groups.read,okta.groups.manage,okta.logs.read`).
  7. Click `Save`.
```

--------------------------------

### Zsh Shell Completion

Source: https://docs.serval.com/sections/cli/installation

Installs Serval CLI shell completion for Zsh. This command downloads the Zsh completion script and sources it, enabling tab completion for Serval commands in Zsh environments.

```zsh
serval completion zsh > ~/.serval-completion.zsh
source ~/.serval-completion.zsh
```

--------------------------------

### Serval Jamf Integration Configuration Steps

Source: https://docs.serval.com/sections/integrations/jamf

Steps to configure the Jamf integration within the Serval application. This involves connecting to Jamf, providing necessary credentials, and saving the settings.

```APIDOC
Serval Integration Configuration:
  1. Navigate to Applications -> Available in Serval.
  2. Find and select the Jamf integration, then press 'Connect'.
  3. Enter the Jamf Instance ID (subdomain of your jamfcloud URL, e.g., 'serval' for serval.jamfcloud.com).
  4. Input the Client ID and Client Secret obtained from the Jamf API Client.
  5. Leave scopes blank.
  6. Click 'Save' to complete the integration.

Note: Serval uses the generated Jamf OAuth token to run workflows. The client secret can be rotated by updating it in Serval via reconnection.
```

--------------------------------

### Serval CLI Commands

Source: https://docs.serval.com/sections/cli/overview

This section lists the available commands for the Serval CLI, including their descriptions. These commands are used for authentication, managing workflows, and displaying information about the CLI.

```bash
serval login
serval logout
serval status
serval pull <team-prefix>
serval push <team-prefix>
serval version
serval help
serval completion
```

--------------------------------

### Example AWS IAM Trust Policy with Okta

Source: https://docs.serval.com/sections/access-management/aws-role-access

An example of an AWS IAM trust policy configured for Serval integration with Okta. It demonstrates the substitution of placeholders with actual Okta domain and Serval OIDC application client ID.

```json
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Federated": "arn:aws:iam::879395235829:oidc-provider/your-domain.okta.com"
            },
            "Action": "sts:AssumeRoleWithWebIdentity",
            "Condition": {
                "StringEquals": {
                    "your-domain.okta.com:aud": "0oakcaaw2r3Cm0ICB1d7"
                }
            }
        }
    ]
}
```

--------------------------------

### Connect Slack to Serval

Source: https://docs.serval.com/sections/integrations/slack

Steps to connect Slack to Serval, involving initiating the connection in Serval and authorizing the application within Slack.

```APIDOC
Step 1: Initiate the Connection
  1. In Serval, find the team you want to connect Slack to under **My Teams**
  2. From there, navigate to **Applications → Available → Slack**
  3. Click **Connect** to begin the OAuth flow

Step 2: Authorize in Slack
You’ll be redirected to Slack’s authorization page:
Slack authorization page - ensure correct workspace is selected
**Important** : Ensure you have the correct Slack workspace selected in the top-right corner before proceeding.
  1. Review the requested permissions
  2. Click **Allow** to authorize the connection

At this point, Slack should be successfully connected to Serval.
```

--------------------------------

### Serval Configuration for Zendesk

Source: https://docs.serval.com/sections/integrations/zendesk

This section details the configuration parameters required within Serval to establish a connection with Zendesk. It includes the instance name, subdomain, admin email, and API token.

```APIDOC
Serval Zendesk Configuration:

1. Navigate to Apps → Available → Zendesk → Connect in Serval.
2. Enter the following details:
   - Instance Name: A user-friendly name for the Zendesk instance (e.g., "Production Zendesk").
   - Subdomain: Your Zendesk subdomain (e.g., "yourcompany.zendesk.com").
   - Email Address: The email address of a Zendesk administrator or agent.
   - API Token: The API token generated from Zendesk (refer to 'Create an API Token' section).
3. Click 'Save' to complete the configuration.
```

--------------------------------

### Update Serval CLI with Homebrew (macOS)

Source: https://docs.serval.com/sections/cli/installation

Updates the Serval CLI to the latest version on macOS using Homebrew. Requires updating Homebrew itself first.

```bash
brew update && brew install --cask servalhq/serval/serval
```

--------------------------------

### Serval CLI Push & Pull Configuration

Source: https://docs.serval.com/sections/documentation/ticketing/serval-ticket

This section details how to use the Serval CLI for pushing and pulling configuration files. It covers the commands and their usage for managing your Serval configurations.

```cli
serval config push
serval config pull
```

--------------------------------

### Serval API Reference - Authentication

Source: https://docs.serval.com/sections/integrations/overview

Provides documentation for the Serval API, specifically focusing on authentication methods like creating tokens. This is crucial for integrating custom applications with Serval.

```APIDOC
Serval API Reference:

Auth API:
  create-token:
    POST /auth/token
    Description: Creates an API token for authentication.
    Request Body:
      type: object
      properties:
        grant_type:
          type: string
          enum: [client_credentials]
          description: The grant type for the token request.
        client_id:
          type: string
          description: Your application's client ID.
        client_secret:
          type: string
          description: Your application's client secret.
    Responses:
      200 OK:
        description: Token created successfully.
        content:
          application/json:
            schema:
              type: object
              properties:
                access_token:
                  type: string
                  description: The generated access token.
                token_type:
                  type: string
                  description: The type of token (e.g., Bearer).
                expires_in:
                  type: integer
                  description: The token's expiration time in seconds.
      400 Bad Request:
        description: Invalid request parameters.
      401 Unauthorized:
        description: Authentication failed.
```

--------------------------------

### Slack Admin Permissions Guidance

Source: https://docs.serval.com/sections/integrations/slack-admin

Provides crucial advice on setting up the Slack Admin integration, focusing on user token requirements and necessary permissions for workspace and channel management.

```APIDOC
Important Setup Considerations:
- Slack Admin uses a user token, inheriting the permissions of the connecting user.
- Must be connected by a primary owner, org owner, or org admin with full permissions.
- Common missing permissions include 'Manage public channels for a team' and 'Manage private channels at the org level'.
- Ensure 'Workspace Admin' account type has all necessary permissions enabled in Slack org settings.
```

--------------------------------

### Access Policy API - Get Approval Procedure

Source: https://docs.serval.com/api-reference/access-policy-api/list-access-policies

Retrieves the approval procedure for a specific access policy. Requires team ID and access policy ID.

```APIDOC
Access Policy API:
  Get Approval Procedure
    GET /v1/teams/{team_id}/access-policies/{access_policy_id}/approval-procedure
    Retrieves the approval procedure for an access policy.
    Parameters:
      Authorization: Bearer <token> (header, required) - Authentication token.
      team_id: string (path, required) - The ID of the Serval team.
      access_policy_id: string (path, required) - The ID of the access policy.
    Responses:
      200 OK:
        content: application/json
        schema:
          type: object
          properties:
            procedure: { type: string, description: "The approval procedure details" }
    Related:
      PUT /v1/teams/{team_id}/access-policies/{access_policy_id}/approval-procedure (Update Approval Procedure)
      POST /v1/teams/{team_id}/access-policies/{access_policy_id}/approval-procedure (Create Approval Procedure)
      DELETE /v1/teams/{team_id}/access-policies/{access_policy_id}/approval-procedure (Delete Approval Procedure)
```

--------------------------------

### Ticket API - Get Ticket

Source: https://docs.serval.com/api-reference/ticket-api/get-ticket

Retrieves a specific ticket by its ID within a given team. Requires Bearer token authentication. Includes details on path parameters and the response schema.

```APIDOC
Ticket API - Get Ticket:
  GET /v1/teams/{team_id}/tickets/{ticket_id}
  Retrieves a specific ticket by its ID.

  Parameters:
    Authorization: Bearer authentication header of the form "Bearer <token>", where "<token>" is your auth token. (string, header, required)
    team_id: The ID of the Serval team that the ticket belongs to. (string, path, required)
    ticket_id: The ID of the Serval ticket to get. (string, path, required)

  Returns:
    200 OK:
      {
        "ticket": {
          "id": "<string>",
          "friendlyIdentifier": "<string>",
          "forTeam": {
            "id": "<string>",
            "name": "<string>"
          },
          "name": "<string>",
          "description": "<string>",
          "createdAt": "1s",
          "completedAt": "1s",
          "escalatedAt": "1s",
          "createdByUser": {
            "id": "<string>",
            "email": "<string>"
          },
          "assignedToUser": {
            "id": "<string>",
            "email": "<string>"
          },
          "status": {
            "id": "<string>",
            "teamId": "<string>",
            "statusGroup": "TICKET_STATUS_GROUP_UNSPECIFIED",
            "name": "<string>",
            "description": "<string>",
            "isDefault": true
          },
          "escalationLevel": "AI",
          "priority": {
            "id": "<string>",
            "teamId": "<string>",
            "priority": "TICKET_PRIORITY_UNSPECIFIED",
            "description": "<string>"
          },
          "slaStartedAt": "1s",
          "slaBreachesAt": "1s",
          "labels": [
            {
              "id": "<string>",
              "teamId": "<string>",
              "name": "<string>",
              "description": "<string>"
            }
          ]
        }
      }
```

```curl
curl --request GET \
  --url https://public.api.serval.com/v1/teams/{team_id}/tickets/{ticket_id} \
  --header 'Authorization: Bearer <token>'
```

--------------------------------

### Serval CLI Push & Pull Configuration

Source: https://docs.serval.com/sections/documentation/overview/welcome

This section details how to use the Serval Command Line Interface (CLI) for pushing and pulling configuration settings. It is essential for managing your Serval deployment's configuration.

```cli
serval config push
serval config pull
```

--------------------------------

### Serval Access Management Overview

Source: https://docs.serval.com/sections/access-management/overview

This section outlines the different methods Serval uses to facilitate access to applications and resources. It covers direct API integrations, linked entitlements, owner-assigned tasks, and custom workflows. It also mentions time-bound access and approval procedures.

```APIDOC
Access Management Overview:
  Serval facilitates access to applications and resources through:
  - Direct API integration (e.g., using Github API calls).
  - Linked entitlements (e.g., granting access to Linear via Okta group membership).
  - Tasks for application owners (e.g., assigning a task to grant Figma access).
  - Custom workflows (e.g., automating Terraform repo updates in Github).

  Access can be:
  - Time-bound, with automatic revocation.
  - Subject to configurable approval procedures.
```

--------------------------------

### Pull Latest Serval Configuration

Source: https://docs.serval.com/sections/cli/push-pull-configuration

Fetches the latest configuration changes from the Serval repository. This command should be run before starting any development work to ensure you are working with the most up-to-date version.

```bash
serval pull EXA
```

--------------------------------

### Serval API Reference - Auth API

Source: https://docs.serval.com/sections/documentation/workflows/create-your-first-workflow

This section details the Serval API for authentication, specifically the 'create-token' endpoint. It outlines the process for generating authentication tokens, which are essential for interacting with the Serval API.

```APIDOC
POST /api/v1/auth/token

Create a new authentication token.

Request Body:
{
  "username": "string",
  "password": "string"
}

Response Body:
{
  "token": "string"
}
```

--------------------------------

### Updating Authentication Configuration

Source: https://docs.serval.com/sections/integrations/custom-app

A step-by-step guide on how to update authentication fields for a custom app in Serval. This process involves obtaining new or old credentials from the third-party service and re-entering them in Serval.

```APIDOC
Updating Configuration:
  1. Go to the third-party service and grab the old credentials OR generate new credentials.
  2. Return to the Custom App configuration in Serval.
  3. Enter the new credentials (old credentials cannot be retrieved).
  4. Click "Save" to update the configuration.
```

--------------------------------

### Jamf Pro Configuration for Serval Integration

Source: https://docs.serval.com/sections/integrations/jamf

Steps to configure Jamf Pro to allow Serval to connect and manage devices. This involves creating an API role with necessary privileges and generating API client credentials (Client ID and Client Secret).

```APIDOC
1. Create or select an API role:
   - Log in to Jamf Pro: `<yourdomain>.[jamfcloud.com]`
   - Navigate to Settings > API roles and clients.
   - Click '+ New' to create a new API Role or select an existing one.
   - Assign a name and select the required privileges for Serval.
   - Save the API Role.

2. Create an API Client:
   - Navigate to the API Clients tab in Settings.
   - Click '+ New' to create a new API Client.
   - Name the client (e.g., 'Serval Integration').
   - Assign the appropriate role(s).
   - Optionally, set a custom Access token lifetime.
   - Ensure the API client is enabled and save.
   - Click 'Generate client secret' to obtain the Client ID and Client Secret.
   - Keep the Client ID and Client Secret secure for the next steps.
```

--------------------------------

### Ticket API - List Tickets

Source: https://docs.serval.com/api-reference/ticket-api/list-tickets

Retrieves a list of tickets for a specified team within a given time range. Requires Bearer token authentication. Supports filtering by start and end times.

```APIDOC
GET /v1/teams/{team_id}/tickets

List tickets for a team within a given time range.

#### Authorizations
- Authorization: Bearer authentication header of the form `Bearer <token>`, where `<token>` is your auth token.

#### Path Parameters
- team_id (string, required): The ID of the Serval team to get tickets for.

#### Query Parameters
- startTime.seconds (integer string<int64>): Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
- startTime.nanos (integer): Non-negative fractions of a second at nanosecond resolution. Must be from 0 to 999,999,999 inclusive.

#### Response Schema (200 OK)
```json
{
  "tickets": [
    {
      "id": "<string>",
      "friendlyIdentifier": "<string>",
      "forTeam": {
        "id": "<string>",
        "name": "<string>"
      },
      "name": "<string>",
      "description": "<string>",
      "createdAt": "1s",
      "completedAt": "1s",
      "escalatedAt": "1s",
      "createdByUser": {
        "id": "<string>",
        "email": "<string>"
      },
      "assignedToUser": {
        "id": "<string>",
        "email": "<string>"
      },
      "status": {
        "id": "<string>",
        "teamId": "<string>",
        "statusGroup": "TICKET_STATUS_GROUP_UNSPECIFIED",
        "name": "<string>",
        "description": "<string>",
        "isDefault": true
      },
      "escalationLevel": "AI",
      "priority": {
        "id": "<string>",
        "teamId": "<string>",
        "priority": "TICKET_PRIORITY_UNSPECIFIED",
        "description": "<string>"
      },
      "slaStartedAt": "1s",
      "slaBreachesAt": "1s",
      "labels": [
        {
          "id": "<string>",
          "teamId": "<string>",
          "name": "<string>",
          "description": "<string>"
        }
      ]
    }
  ]
}
```
```

```curl
curl --request GET \
  --url https://public.api.serval.com/v1/teams/{team_id}/tickets \
  --header 'Authorization: Bearer <token>'
```

--------------------------------

### Serval Chat Commands for Ticket Management

Source: https://docs.serval.com/sections/documentation/ticketing/serval-ticket

Provides examples of natural language commands used within the Serval chat interface to manage tickets, such as reassigning tickets, running workflows, and adding internal notes.

```serval-chat
Reassigning tickets:
  Mention the agent or use @ mention.

Running workflows:
  Use slash commands (e.g., /workflow_name).

Adding internal notes:
  Toggle between customer-visible messages and internal notes.
```
Tokens:
Raw