NAV
Shell HTTP JavaScript Node.js Ruby Python Java Go PHP

# Wekan REST API v7.63

> Scroll down for code samples, example requests and responses. Select a language for code samples from the tabs above or the mobile navigation menu.

The REST API allows you to control and extend Wekan with ease.

If you are an end-user and not a dev or a tester, create an issue to request new APIs.

> All API calls in the documentation are made using `curl`. However, you are free to use Java / Python / PHP / Golang / Ruby / Swift / Objective-C / Rust / Scala / C# or any other programming languages.

# Production Security Concerns

When calling a production Wekan server, ensure it is running via HTTPS and has a valid SSL Certificate. The login method requires you to post your username and password in plaintext, which is why we highly suggest only calling the REST login api over HTTPS. Also, few things to note:

- Only call via HTTPS
- Implement a timed authorization token expiration strategy
- Ensure the calling user only has permissions for what they are calling and no more

# Authentication

- API Key (UserSecurity)
  - Parameter Name: Authorization, in: header.

# Login

> Code samples

    # You can also use wget
    curl -X POST /users/login \
      -H 'Content-Type: application/x-www-form-urlencoded' \
      -H 'Accept: */*'

    POST /users/login HTTP/1.1

    Content-Type: application/x-www-form-urlencoded
    Accept: */*

    const inputBody = '{
      "username": "string",
      "password": "pa$$word"
    }';
    const headers = {
      'Content-Type':'application/x-www-form-urlencoded',
      'Accept':'*/*'
    };

    fetch('/users/login',
    {
      method: 'POST',
      body: inputBody,
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');
    const inputBody = {
      "username": "string",
      "password": "pa$$word"
    };
    const headers = {
      'Content-Type':'application/x-www-form-urlencoded',
      'Accept':'*/*'
    };

    fetch('/users/login',
    {
      method: 'POST',
      body: JSON.stringify(inputBody),
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Content-Type' => 'application/x-www-form-urlencoded',
      'Accept' => '*/*'
    }

    result = RestClient.post '/users/login',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Content-Type': 'application/x-www-form-urlencoded',
      'Accept': '*/*'
    }

    r = requests.post('/users/login', headers = headers)

    print(r.json())

    URL obj = new URL("/users/login");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("POST");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Content-Type": []string{"application/x-www-form-urlencoded"},
            "Accept": []string{"*/*"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("POST", "/users/login", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/x-www-form-urlencoded',
        'Accept' => '*/*',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('POST','/users/login', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`POST /users/login`

Login with REST API

> Body parameter

    username: string
    password: pa$$word

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
body | body | object | true | none
» username | body | string | true | Your username
» password | body | string(password) | true | Your password

> Example responses

> 200 Response

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | Successful authentication | Inline
400 | Bad Request | Error in authentication | Inline
default | Default | Error in authentication | None

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» id | string | false | none | none
» token | string | false | none | none
» tokenExpires | string | false | none | none

Status Code 400

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» error | number | false | none | none
» reason | string | false | none | none

This operation does not require authentication

## register

> Code samples

    # You can also use wget
    curl -X POST /users/register \
      -H 'Content-Type: application/x-www-form-urlencoded' \
      -H 'Accept: */*'

    POST /users/register HTTP/1.1

    Content-Type: application/x-www-form-urlencoded
    Accept: */*

    const inputBody = '{
      "username": "string",
      "password": "pa$$word",
      "email": "string"
    }';
    const headers = {
      'Content-Type':'application/x-www-form-urlencoded',
      'Accept':'*/*'
    };

    fetch('/users/register',
    {
      method: 'POST',
      body: inputBody,
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');
    const inputBody = {
      "username": "string",
      "password": "pa$$word",
      "email": "string"
    };
    const headers = {
      'Content-Type':'application/x-www-form-urlencoded',
      'Accept':'*/*'
    };

    fetch('/users/register',
    {
      method: 'POST',
      body: JSON.stringify(inputBody),
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Content-Type' => 'application/x-www-form-urlencoded',
      'Accept' => '*/*'
    }

    result = RestClient.post '/users/register',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Content-Type': 'application/x-www-form-urlencoded',
      'Accept': '*/*'
    }

    r = requests.post('/users/register', headers = headers)

    print(r.json())

    URL obj = new URL("/users/register");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("POST");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Content-Type": []string{"application/x-www-form-urlencoded"},
            "Accept": []string{"*/*"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("POST", "/users/register", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/x-www-form-urlencoded',
        'Accept' => '*/*',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('POST','/users/register', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`POST /users/register`

Register with REST API

Notes:

- You will need to provide the token for any of the authenticated methods.

> Body parameter

    username: string
    password: pa$$word
    email: string

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
body | body | object | true | none
» username | body | string | true | Your username
» password | body | string(password) | true | Your password
» email | body | string | true | Your email

> Example responses

> 200 Response

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | Successful registration | Inline
400 | Bad Request | Error in registration | Inline
default | Default | Error in registration | None

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» id | string | false | none | none
» token | string | false | none | none
» tokenExpires | string | false | none | none

Status Code 400

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» error | number | false | none | none
» reason | string | false | none | none

This operation does not require authentication

# Boards

## get_public_boards

> Code samples

    # You can also use wget
    curl -X GET /api/boards \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    GET /api/boards HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.get '/api/boards',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.get('/api/boards', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("GET");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("GET", "/api/boards", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('GET','/api/boards', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`GET /api/boards`

Get all public boards

> Example responses

> 200 Response

    [
      {
        "_id": "string",
        "title": "string"
      }
    ]

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none
» title | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## new_board

> Code samples

    # You can also use wget
    curl -X POST /api/boards \
      -H 'Content-Type: multipart/form-data' \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    POST /api/boards HTTP/1.1

    Content-Type: multipart/form-data
    Accept: application/json

    const inputBody = '{
      "title": "string",
      "owner": "string",
      "isAdmin": true,
      "isActive": true,
      "isNoComments": true,
      "isCommentOnly": true,
      "isWorker": true,
      "permission": "string",
      "color": "string"
    }';
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards',
    {
      method: 'POST',
      body: inputBody,
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');
    const inputBody = {
      "title": "string",
      "owner": "string",
      "isAdmin": true,
      "isActive": true,
      "isNoComments": true,
      "isCommentOnly": true,
      "isWorker": true,
      "permission": "string",
      "color": "string"
    };
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards',
    {
      method: 'POST',
      body: JSON.stringify(inputBody),
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Content-Type' => 'multipart/form-data',
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.post '/api/boards',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Content-Type': 'multipart/form-data',
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.post('/api/boards', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("POST");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Content-Type": []string{"multipart/form-data"},
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("POST", "/api/boards", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'multipart/form-data',
        'Accept' => 'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('POST','/api/boards', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`POST /api/boards`

Create a board

This allows to create a board.

The color has to be chosen between `belize`, `nephritis`, `pomegranate`, `pumpkin`, `wisteria`, `moderatepink`, `strongcyan`, `limegreen`, `midnight`, `dark`, `relax`, `corteza`:

> Body parameter

    title: string
    owner: string
    isAdmin: true
    isActive: true
    isNoComments: true
    isCommentOnly: true
    isWorker: true
    permission: string
    color: string

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
body | body | object | true | none
» title | body | string | true | the new title of the board
» owner | body | string | true | "ABCDE12345" <= User ID in Wekan.
» isAdmin | body | boolean | false | is the owner an admin of the board (default true)
» isActive | body | boolean | false | is the board active (default true)
» isNoComments | body | boolean | false | disable comments (default false)
» isCommentOnly | body | boolean | false | only enable comments (default false)
» isWorker | body | boolean | false | only move cards, assign himself to card and comment (default false)
» permission | body | string | false | "private" board <== Set to "public" if you
» color | body | string | false | the color of the board

#### Detailed descriptions

» owner: "ABCDE12345" <= User ID in Wekan. (Not username or email)

» permission: "private" board <== Set to "public" if you want public Wekan board

> Example responses

> 200 Response

    {
      "_id": "string",
      "defaultSwimlaneId": "string"
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none
» defaultSwimlaneId | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## get_board

> Code samples

    # You can also use wget
    curl -X GET /api/boards/{board} \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    GET /api/boards/{board} HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.get '/api/boards/{board}',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.get('/api/boards/{board}', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("GET");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("GET", "/api/boards/{board}", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('GET','/api/boards/{board}', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`GET /api/boards/{board}`

Get the board with that particular ID

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the ID of the board to retrieve the data

#### Detailed descriptions

board: the ID of the board to retrieve the data

> Example responses

> 200 Response

    {
      "title": "string",
      "slug": "string",
      "archived": true,
      "archivedAt": "string",
      "createdAt": "string",
      "modifiedAt": "string",
      "stars": 0,
      "labels": [
        {
          "_id": "string",
          "name": "string",
          "color": "white"
        }
      ],
      "members": [
        {
          "userId": "string",
          "isAdmin": true,
          "isActive": true,
          "isNoComments": true,
          "isCommentOnly": true,
          "isWorker": true
        }
      ],
      "permission": "public",
      "orgs": [
        {
          "orgId": "string",
          "orgDisplayName": "string",
          "isActive": true
        }
      ],
      "teams": [
        {
          "teamId": "string",
          "teamDisplayName": "string",
          "isActive": true
        }
      ],
      "color": "belize",
      "backgroundImageURL": "string",
      "allowsCardCounterList": true,
      "allowsBoardMemberList": true,
      "description": "string",
      "subtasksDefaultBoardId": "string",
      "subtasksDefaultListId": "string",
      "dateSettingsDefaultBoardId": "string",
      "dateSettingsDefaultListId": "string",
      "allowsSubtasks": true,
      "allowsAttachments": true,
      "allowsChecklists": true,
      "allowsComments": true,
      "allowsDescriptionTitle": true,
      "allowsDescriptionText": true,
      "allowsDescriptionTextOnMinicard": true,
      "allowsCoverAttachmentOnMinicard": true,
      "allowsBadgeAttachmentOnMinicard": true,
      "allowsCardSortingByNumberOnMinicard": true,
      "allowsCardNumber": true,
      "allowsActivities": true,
      "allowsLabels": true,
      "allowsCreator": true,
      "allowsCreatorOnMinicard": true,
      "allowsAssignee": true,
      "allowsMembers": true,
      "allowsRequestedBy": true,
      "allowsCardSortingByNumber": true,
      "allowsShowLists": true,
      "allowsAssignedBy": true,
      "allowsReceivedDate": true,
      "allowsStartDate": true,
      "allowsEndDate": true,
      "allowsDueDate": true,
      "presentParentTask": "prefix-with-full-path",
      "receivedAt": "string",
      "startAt": "string",
      "dueAt": "string",
      "endAt": "string",
      "spentTime": 0,
      "isOvertime": true,
      "type": "board",
      "sort": 0
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Boards

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## delete_board

> Code samples

    # You can also use wget
    curl -X DELETE /api/boards/{board} \
      -H 'Authorization: API_KEY'

    DELETE /api/boards/{board} HTTP/1.1

    const headers = {
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}',
    {
      method: 'DELETE',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}',
    {
      method: 'DELETE',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Authorization' => 'API_KEY'
    }

    result = RestClient.delete '/api/boards/{board}',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Authorization': 'API_KEY'
    }

    r = requests.delete('/api/boards/{board}', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("DELETE");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("DELETE", "/api/boards/{board}", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('DELETE','/api/boards/{board}', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`DELETE /api/boards/{board}`

Delete a board

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the ID of the board

#### Detailed descriptions

board: the ID of the board

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | None

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## get_board_attachments

> Code samples

    # You can also use wget
    curl -X GET /api/boards/{board}/attachments \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    GET /api/boards/{board}/attachments HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/attachments',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/attachments',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.get '/api/boards/{board}/attachments',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.get('/api/boards/{board}/attachments', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/attachments");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("GET");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("GET", "/api/boards/{board}/attachments", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('GET','/api/boards/{board}/attachments', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`GET /api/boards/{board}/attachments`

Get the list of attachments of a board

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID

#### Detailed descriptions

board: the board ID

> Example responses

> 200 Response

    [
      {
        "attachmentId": "string",
        "attachmentName": "string",
        "attachmentType": "string",
        "url": "string",
        "urlDownload": "string",
        "boardId": "string",
        "swimlaneId": "string",
        "listId": "string",
        "cardId": "string"
      }
    ]

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» attachmentId | string | false | none | none
» attachmentName | string | false | none | none
» attachmentType | string | false | none | none
» url | string | false | none | none
» urlDownload | string | false | none | none
» boardId | string | false | none | none
» swimlaneId | string | false | none | none
» listId | string | false | none | none
» cardId | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## exportJson

> Code samples

    # You can also use wget
    curl -X GET /api/boards/{board}/export \
      -H 'Authorization: API_KEY'

    GET /api/boards/{board}/export HTTP/1.1

    const headers = {
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/export',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/export',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Authorization' => 'API_KEY'
    }

    result = RestClient.get '/api/boards/{board}/export',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Authorization': 'API_KEY'
    }

    r = requests.get('/api/boards/{board}/export', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/export");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("GET");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("GET", "/api/boards/{board}/export", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('GET','/api/boards/{board}/export', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`GET /api/boards/{board}/export`

This route is used to export the board to a json file format.

If user is already logged-in, pass loginToken as param "authToken": '/api/boards/:boardId/export?authToken=:token'

See https://blog.kayla.com.au/server-side-route-authentication-in-meteor/ for detailed explanations

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the ID of the board we are exporting

#### Detailed descriptions

board: the ID of the board we are exporting

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | None

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## copy_board

> Code samples

    # You can also use wget
    curl -X POST /api/boards/{board}/copy \
      -H 'Content-Type: multipart/form-data' \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    POST /api/boards/{board}/copy HTTP/1.1

    Content-Type: multipart/form-data
    Accept: application/json

    const inputBody = '{
      "title": "string"
    }';
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/copy',
    {
      method: 'POST',
      body: inputBody,
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');
    const inputBody = {
      "title": "string"
    };
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/copy',
    {
      method: 'POST',
      body: JSON.stringify(inputBody),
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Content-Type' => 'multipart/form-data',
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.post '/api/boards/{board}/copy',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Content-Type': 'multipart/form-data',
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.post('/api/boards/{board}/copy', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/copy");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("POST");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Content-Type": []string{"multipart/form-data"},
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("POST", "/api/boards/{board}/copy", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'multipart/form-data',
        'Accept' => 'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('POST','/api/boards/{board}/copy', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`POST /api/boards/{board}/copy`

Copy a board to a new one

If your are board admin or wekan admin, this copies the given board to a new one.

> Body parameter

    title: string

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board
body | body | object | true | none
» title | body | string | true | the title of the new board (default to old one)

#### Detailed descriptions

board: the board

> Example responses

> 200 Response

    "string"

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | string

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## add_board_label

> Code samples

    # You can also use wget
    curl -X PUT /api/boards/{board}/labels \
      -H 'Content-Type: multipart/form-data' \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    PUT /api/boards/{board}/labels HTTP/1.1

    Content-Type: multipart/form-data
    Accept: application/json

    const inputBody = '{
      "label": "string"
    }';
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/labels',
    {
      method: 'PUT',
      body: inputBody,
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');
    const inputBody = {
      "label": "string"
    };
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/labels',
    {
      method: 'PUT',
      body: JSON.stringify(inputBody),
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Content-Type' => 'multipart/form-data',
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.put '/api/boards/{board}/labels',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Content-Type': 'multipart/form-data',
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.put('/api/boards/{board}/labels', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/labels");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("PUT");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Content-Type": []string{"multipart/form-data"},
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("PUT", "/api/boards/{board}/labels", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'multipart/form-data',
        'Accept' => 'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('PUT','/api/boards/{board}/labels', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`PUT /api/boards/{board}/labels`

Add a label to a board

If the board doesn't have the name/color label, this function adds the label to the board.

> Body parameter

    label: string

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board
body | body | object | true | none
» label | body | string | true | the label value

#### Detailed descriptions

board: the board

> Example responses

> 200 Response

    "string"

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | string

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## set_board_member_permission

> Code samples

    # You can also use wget
    curl -X POST /api/boards/{board}/members/{member} \
      -H 'Content-Type: multipart/form-data' \
      -H 'Authorization: API_KEY'

    POST /api/boards/{board}/members/{member} HTTP/1.1

    Content-Type: multipart/form-data

    const inputBody = '{
      "isAdmin": true,
      "isNoComments": true,
      "isCommentOnly": true,
      "isWorker": true
    }';
    const headers = {
      'Content-Type':'multipart/form-data',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/members/{member}',
    {
      method: 'POST',
      body: inputBody,
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');
    const inputBody = {
      "isAdmin": true,
      "isNoComments": true,
      "isCommentOnly": true,
      "isWorker": true
    };
    const headers = {
      'Content-Type':'multipart/form-data',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/members/{member}',
    {
      method: 'POST',
      body: JSON.stringify(inputBody),
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Content-Type' => 'multipart/form-data',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.post '/api/boards/{board}/members/{member}',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Content-Type': 'multipart/form-data',
      'Authorization': 'API_KEY'
    }

    r = requests.post('/api/boards/{board}/members/{member}', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/members/{member}");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("POST");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Content-Type": []string{"multipart/form-data"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("POST", "/api/boards/{board}/members/{member}", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'multipart/form-data',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('POST','/api/boards/{board}/members/{member}', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`POST /api/boards/{board}/members/{member}`

Change the permission of a member of a board

> Body parameter

    isAdmin: true
    isNoComments: true
    isCommentOnly: true
    isWorker: true

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the ID of the board that we are changing
member | path | string | true | the ID of the user to change permissions
body | body | object | true | none
» isAdmin | body | boolean | true | admin capability
» isNoComments | body | boolean | true | NoComments capability
» isCommentOnly | body | boolean | true | CommentsOnly capability
» isWorker | body | boolean | true | Worker capability

#### Detailed descriptions

board: the ID of the board that we are changing

member: the ID of the user to change permissions

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | None

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## update_board_title

> Code samples

    # You can also use wget
    curl -X PUT /api/boards/{board}/title \
      -H 'Content-Type: multipart/form-data' \
      -H 'Authorization: API_KEY'

    PUT /api/boards/{board}/title HTTP/1.1

    Content-Type: multipart/form-data

    const inputBody = '{
      "title": "string"
    }';
    const headers = {
      'Content-Type':'multipart/form-data',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/title',
    {
      method: 'PUT',
      body: inputBody,
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');
    const inputBody = {
      "title": "string"
    };
    const headers = {
      'Content-Type':'multipart/form-data',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/title',
    {
      method: 'PUT',
      body: JSON.stringify(inputBody),
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Content-Type' => 'multipart/form-data',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.put '/api/boards/{board}/title',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Content-Type': 'multipart/form-data',
      'Authorization': 'API_KEY'
    }

    r = requests.put('/api/boards/{board}/title', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/title");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("PUT");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Content-Type": []string{"multipart/form-data"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("PUT", "/api/boards/{board}/title", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'multipart/form-data',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('PUT','/api/boards/{board}/title', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`PUT /api/boards/{board}/title`

Update the title of a board

> Body parameter

    title: string

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the ID of the board to update
body | body | object | true | none
» title | body | string | true | the new title for the board

#### Detailed descriptions

board: the ID of the board to update

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | None

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## get_boards_count

> Code samples

    # You can also use wget
    curl -X GET /api/boards_count \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    GET /api/boards_count HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards_count',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards_count',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.get '/api/boards_count',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.get('/api/boards_count', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards_count");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("GET");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("GET", "/api/boards_count", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('GET','/api/boards_count', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`GET /api/boards_count`

Get public and private boards count

> Example responses

> 200 Response

    {
      "private": 0,
      "public": 0
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» private | integer | false | none | none
» public | integer | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## get_boards_from_user

> Code samples

    # You can also use wget
    curl -X GET /api/users/{user}/boards \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    GET /api/users/{user}/boards HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/users/{user}/boards',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/users/{user}/boards',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.get '/api/users/{user}/boards',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.get('/api/users/{user}/boards', headers = headers)

    print(r.json())

    URL obj = new URL("/api/users/{user}/boards");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("GET");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("GET", "/api/users/{user}/boards", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('GET','/api/users/{user}/boards', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`GET /api/users/{user}/boards`

Get all boards attached to a user

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
user | path | string | true | the ID of the user to retrieve the data

#### Detailed descriptions

user: the ID of the user to retrieve the data

> Example responses

> 200 Response

    [
      {
        "_id": "string",
        "title": "string"
      }
    ]

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none
» title | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

# Checklists

## get_all_checklists

> Code samples

    # You can also use wget
    curl -X GET /api/boards/{board}/cards/{card}/checklists \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    GET /api/boards/{board}/cards/{card}/checklists HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/cards/{card}/checklists',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/cards/{card}/checklists',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.get '/api/boards/{board}/cards/{card}/checklists',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.get('/api/boards/{board}/cards/{card}/checklists', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/cards/{card}/checklists");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("GET");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("GET", "/api/boards/{board}/cards/{card}/checklists", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('GET','/api/boards/{board}/cards/{card}/checklists', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`GET /api/boards/{board}/cards/{card}/checklists`

Get the list of checklists attached to a card

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID
card | path | string | true | the card ID

#### Detailed descriptions

board: the board ID

card: the card ID

> Example responses

> 200 Response

    [
      {
        "_id": "string",
        "title": "string"
      }
    ]

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none
» title | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## new_checklist

> Code samples

    # You can also use wget
    curl -X POST /api/boards/{board}/cards/{card}/checklists \
      -H 'Content-Type: multipart/form-data' \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    POST /api/boards/{board}/cards/{card}/checklists HTTP/1.1

    Content-Type: multipart/form-data
    Accept: application/json

    const inputBody = '{
      "title": "string",
      "items": "string"
    }';
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/cards/{card}/checklists',
    {
      method: 'POST',
      body: inputBody,
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');
    const inputBody = {
      "title": "string",
      "items": "string"
    };
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/cards/{card}/checklists',
    {
      method: 'POST',
      body: JSON.stringify(inputBody),
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Content-Type' => 'multipart/form-data',
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.post '/api/boards/{board}/cards/{card}/checklists',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Content-Type': 'multipart/form-data',
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.post('/api/boards/{board}/cards/{card}/checklists', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/cards/{card}/checklists");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("POST");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Content-Type": []string{"multipart/form-data"},
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("POST", "/api/boards/{board}/cards/{card}/checklists", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'multipart/form-data',
        'Accept' => 'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('POST','/api/boards/{board}/cards/{card}/checklists', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`POST /api/boards/{board}/cards/{card}/checklists`

create a new checklist

> Body parameter

    title: string
    items: string

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID
card | path | string | true | the card ID
body | body | object | true | none
» title | body | string | true | the title of the new checklist
» items | body | string | false | the list of items on the new checklist

#### Detailed descriptions

board: the board ID

card: the card ID

> Example responses

> 200 Response

    {
      "_id": "string"
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## get_checklist

> Code samples

    # You can also use wget
    curl -X GET /api/boards/{board}/cards/{card}/checklists/{checklist} \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    GET /api/boards/{board}/cards/{card}/checklists/{checklist} HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/cards/{card}/checklists/{checklist}',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/cards/{card}/checklists/{checklist}',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.get '/api/boards/{board}/cards/{card}/checklists/{checklist}',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.get('/api/boards/{board}/cards/{card}/checklists/{checklist}', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/cards/{card}/checklists/{checklist}");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("GET");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("GET", "/api/boards/{board}/cards/{card}/checklists/{checklist}", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('GET','/api/boards/{board}/cards/{card}/checklists/{checklist}', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`GET /api/boards/{board}/cards/{card}/checklists/{checklist}`

Get a checklist

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID
card | path | string | true | the card ID
checklist | path | string | true | the ID of the checklist

#### Detailed descriptions

board: the board ID

card: the card ID

checklist: the ID of the checklist

> Example responses

> 200 Response

    {
      "cardId": "string",
      "title": "string",
      "finishedAt": "string",
      "createdAt": "string",
      "sort": 0,
      "items": [
        {
          "_id": "string",
          "title": "string",
          "isFinished": true
        }
      ]
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» cardId | string | false | none | none
» title | string | false | none | none
» finishedAt | string | false | none | none
» createdAt | string | false | none | none
» sort | number | false | none | none
» items | [object] | false | none | none
»» _id | string | false | none | none
»» title | string | false | none | none
»» isFinished | boolean | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## delete_checklist

> Code samples

    # You can also use wget
    curl -X DELETE /api/boards/{board}/cards/{card}/checklists/{checklist} \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    DELETE /api/boards/{board}/cards/{card}/checklists/{checklist} HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/cards/{card}/checklists/{checklist}',
    {
      method: 'DELETE',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/cards/{card}/checklists/{checklist}',
    {
      method: 'DELETE',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.delete '/api/boards/{board}/cards/{card}/checklists/{checklist}',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.delete('/api/boards/{board}/cards/{card}/checklists/{checklist}', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/cards/{card}/checklists/{checklist}");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("DELETE");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("DELETE", "/api/boards/{board}/cards/{card}/checklists/{checklist}", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('DELETE','/api/boards/{board}/cards/{card}/checklists/{checklist}', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`DELETE /api/boards/{board}/cards/{card}/checklists/{checklist}`

Delete a checklist

The checklist will be removed, not put in the recycle bin.

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID
card | path | string | true | the card ID
checklist | path | string | true | the ID of the checklist to remove

#### Detailed descriptions

board: the board ID

card: the card ID

checklist: the ID of the checklist to remove

> Example responses

> 200 Response

    {
      "_id": "string"
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

# ChecklistItems

## new_checklist_item

> Code samples

    # You can also use wget
    curl -X POST /api/boards/{board}/cards/{card}/checklists/{checklist}/items \
      -H 'Content-Type: multipart/form-data' \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    POST /api/boards/{board}/cards/{card}/checklists/{checklist}/items HTTP/1.1

    Content-Type: multipart/form-data
    Accept: application/json

    const inputBody = '{
      "title": "string"
    }';
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/cards/{card}/checklists/{checklist}/items',
    {
      method: 'POST',
      body: inputBody,
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');
    const inputBody = {
      "title": "string"
    };
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/cards/{card}/checklists/{checklist}/items',
    {
      method: 'POST',
      body: JSON.stringify(inputBody),
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Content-Type' => 'multipart/form-data',
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.post '/api/boards/{board}/cards/{card}/checklists/{checklist}/items',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Content-Type': 'multipart/form-data',
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.post('/api/boards/{board}/cards/{card}/checklists/{checklist}/items', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/cards/{card}/checklists/{checklist}/items");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("POST");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Content-Type": []string{"multipart/form-data"},
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("POST", "/api/boards/{board}/cards/{card}/checklists/{checklist}/items", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'multipart/form-data',
        'Accept' => 'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('POST','/api/boards/{board}/cards/{card}/checklists/{checklist}/items', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`POST /api/boards/{board}/cards/{card}/checklists/{checklist}/items`

add a new item to a checklist

> Body parameter

    title: string

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID
card | path | string | true | the card ID
checklist | path | string | true | the ID of the checklist
body | body | object | true | none
» title | body | string | true | the title of the new item

#### Detailed descriptions

board: the board ID

card: the card ID

checklist: the ID of the checklist

> Example responses

> 200 Response

    {
      "_id": "string"
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## get_checklist_item

> Code samples

    # You can also use wget
    curl -X GET /api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item} \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    GET /api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item} HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.get '/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.get('/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("GET");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("GET", "/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('GET','/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`GET /api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}`

Get a checklist item

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID
card | path | string | true | the card ID
checklist | path | string | true | the checklist ID
item | path | string | true | the ID of the item

#### Detailed descriptions

board: the board ID

card: the card ID

checklist: the checklist ID

item: the ID of the item

> Example responses

> 200 Response

    {
      "title": "string",
      "sort": 0,
      "isFinished": true,
      "checklistId": "string",
      "cardId": "string",
      "createdAt": "string",
      "modifiedAt": "string"
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | ChecklistItems

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## edit_checklist_item

> Code samples

    # You can also use wget
    curl -X PUT /api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item} \
      -H 'Content-Type: multipart/form-data' \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    PUT /api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item} HTTP/1.1

    Content-Type: multipart/form-data
    Accept: application/json

    const inputBody = '{
      "isFinished": "string",
      "title": "string"
    }';
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}',
    {
      method: 'PUT',
      body: inputBody,
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');
    const inputBody = {
      "isFinished": "string",
      "title": "string"
    };
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}',
    {
      method: 'PUT',
      body: JSON.stringify(inputBody),
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Content-Type' => 'multipart/form-data',
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.put '/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Content-Type': 'multipart/form-data',
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.put('/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("PUT");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Content-Type": []string{"multipart/form-data"},
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("PUT", "/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'multipart/form-data',
        'Accept' => 'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('PUT','/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`PUT /api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}`

Edit a checklist item

> Body parameter

    isFinished: string
    title: string

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID
card | path | string | true | the card ID
checklist | path | string | true | the checklist ID
item | path | string | true | the ID of the item
body | body | object | false | none
» isFinished | body | string | false | is the item checked?
» title | body | string | false | the new text of the item

#### Detailed descriptions

board: the board ID

card: the card ID

checklist: the checklist ID

item: the ID of the item

> Example responses

> 200 Response

    {
      "_id": "string"
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## delete_checklist_item

> Code samples

    # You can also use wget
    curl -X DELETE /api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item} \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    DELETE /api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item} HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}',
    {
      method: 'DELETE',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}',
    {
      method: 'DELETE',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.delete '/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.delete('/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("DELETE");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("DELETE", "/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('DELETE','/api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`DELETE /api/boards/{board}/cards/{card}/checklists/{checklist}/items/{item}`

Delete a checklist item

Note: this operation can't be reverted.

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID
card | path | string | true | the card ID
checklist | path | string | true | the checklist ID
item | path | string | true | the ID of the item to be removed

#### Detailed descriptions

board: the board ID

card: the card ID

checklist: the checklist ID

item: the ID of the item to be removed

> Example responses

> 200 Response

    {
      "_id": "string"
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

# CardComments

## get_all_comments

> Code samples

    # You can also use wget
    curl -X GET /api/boards/{board}/cards/{card}/comments \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    GET /api/boards/{board}/cards/{card}/comments HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/cards/{card}/comments',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/cards/{card}/comments',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.get '/api/boards/{board}/cards/{card}/comments',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.get('/api/boards/{board}/cards/{card}/comments', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/cards/{card}/comments");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("GET");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("GET", "/api/boards/{board}/cards/{card}/comments", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('GET','/api/boards/{board}/cards/{card}/comments', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`GET /api/boards/{board}/cards/{card}/comments`

Get all comments attached to a card

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID of the card
card | path | string | true | the ID of the card

#### Detailed descriptions

board: the board ID of the card

card: the ID of the card

> Example responses

> 200 Response

    [
      {
        "_id": "string",
        "comment": "string",
        "authorId": "string"
      }
    ]

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none
» comment | string | false | none | none
» authorId | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## new_comment

> Code samples

    # You can also use wget
    curl -X POST /api/boards/{board}/cards/{card}/comments \
      -H 'Content-Type: multipart/form-data' \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    POST /api/boards/{board}/cards/{card}/comments HTTP/1.1

    Content-Type: multipart/form-data
    Accept: application/json

    const inputBody = '{
      "authorId": "string",
      "comment": "string"
    }';
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/cards/{card}/comments',
    {
      method: 'POST',
      body: inputBody,
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');
    const inputBody = {
      "authorId": "string",
      "comment": "string"
    };
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/cards/{card}/comments',
    {
      method: 'POST',
      body: JSON.stringify(inputBody),
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Content-Type' => 'multipart/form-data',
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.post '/api/boards/{board}/cards/{card}/comments',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Content-Type': 'multipart/form-data',
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.post('/api/boards/{board}/cards/{card}/comments', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/cards/{card}/comments");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("POST");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Content-Type": []string{"multipart/form-data"},
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("POST", "/api/boards/{board}/cards/{card}/comments", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'multipart/form-data',
        'Accept' => 'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('POST','/api/boards/{board}/cards/{card}/comments', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`POST /api/boards/{board}/cards/{card}/comments`

Add a comment on a card

> Body parameter

    authorId: string
    comment: string

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID of the card
card | path | string | true | the ID of the card
body | body | object | true | none
» authorId | body | string | true | the user who 'posted' the comment
» comment | body | string | true | the comment value

#### Detailed descriptions

board: the board ID of the card

card: the ID of the card

> Example responses

> 200 Response

    {
      "_id": "string"
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## get_comment

> Code samples

    # You can also use wget
    curl -X GET /api/boards/{board}/cards/{card}/comments/{comment} \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    GET /api/boards/{board}/cards/{card}/comments/{comment} HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/cards/{card}/comments/{comment}',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/cards/{card}/comments/{comment}',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.get '/api/boards/{board}/cards/{card}/comments/{comment}',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.get('/api/boards/{board}/cards/{card}/comments/{comment}', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/cards/{card}/comments/{comment}");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("GET");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("GET", "/api/boards/{board}/cards/{card}/comments/{comment}", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('GET','/api/boards/{board}/cards/{card}/comments/{comment}', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`GET /api/boards/{board}/cards/{card}/comments/{comment}`

Get a comment on a card

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID of the card
card | path | string | true | the ID of the card
comment | path | string | true | the ID of the comment to retrieve

#### Detailed descriptions

board: the board ID of the card

card: the ID of the card

comment: the ID of the comment to retrieve

> Example responses

> 200 Response

    {
      "boardId": "string",
      "cardId": "string",
      "text": "string",
      "createdAt": "string",
      "modifiedAt": "string",
      "userId": "string"
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | CardComments

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## delete_comment

> Code samples

    # You can also use wget
    curl -X DELETE /api/boards/{board}/cards/{card}/comments/{comment} \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    DELETE /api/boards/{board}/cards/{card}/comments/{comment} HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/cards/{card}/comments/{comment}',
    {
      method: 'DELETE',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/cards/{card}/comments/{comment}',
    {
      method: 'DELETE',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.delete '/api/boards/{board}/cards/{card}/comments/{comment}',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.delete('/api/boards/{board}/cards/{card}/comments/{comment}', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/cards/{card}/comments/{comment}");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("DELETE");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("DELETE", "/api/boards/{board}/cards/{card}/comments/{comment}", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('DELETE','/api/boards/{board}/cards/{card}/comments/{comment}', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`DELETE /api/boards/{board}/cards/{card}/comments/{comment}`

Delete a comment on a card

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID of the card
card | path | string | true | the ID of the card
comment | path | string | true | the ID of the comment to delete

#### Detailed descriptions

board: the board ID of the card

card: the ID of the card

comment: the ID of the comment to delete

> Example responses

> 200 Response

    {
      "_id": "string"
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

# Cards

## get_cards_by_custom_field

> Code samples

    # You can also use wget
    curl -X GET /api/boards/{board}/cardsByCustomField/{customField}/{customFieldValue} \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    GET /api/boards/{board}/cardsByCustomField/{customField}/{customFieldValue} HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/cardsByCustomField/{customField}/{customFieldValue}',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/cardsByCustomField/{customField}/{customFieldValue}',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.get '/api/boards/{board}/cardsByCustomField/{customField}/{customFieldValue}',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.get('/api/boards/{board}/cardsByCustomField/{customField}/{customFieldValue}', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/cardsByCustomField/{customField}/{customFieldValue}");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("GET");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("GET", "/api/boards/{board}/cardsByCustomField/{customField}/{customFieldValue}", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('GET','/api/boards/{board}/cardsByCustomField/{customField}/{customFieldValue}', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`GET /api/boards/{board}/cardsByCustomField/{customField}/{customFieldValue}`

Get all Cards that matchs a value of a specific custom field

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID
customField | path | string | true | the list ID
customFieldValue | path | string | true | the value to look for

#### Detailed descriptions

board: the board ID

customField: the list ID

customFieldValue: the value to look for

> Example responses

> 200 Response

    [
      {
        "_id": "string",
        "title": "string",
        "description": "string",
        "listId": "string",
        "swinlaneId": "string"
      }
    ]

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none
» title | string | false | none | none
» description | string | false | none | none
» listId | string | false | none | none
» swinlaneId | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## get_board_cards_count

> Code samples

    # You can also use wget
    curl -X GET /api/boards/{board}/cards_count \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    GET /api/boards/{board}/cards_count HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/cards_count',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/cards_count',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.get '/api/boards/{board}/cards_count',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.get('/api/boards/{board}/cards_count', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/cards_count");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("GET");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("GET", "/api/boards/{board}/cards_count", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('GET','/api/boards/{board}/cards_count', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`GET /api/boards/{board}/cards_count`

Get a cards count to a board

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID

#### Detailed descriptions

board: the board ID

> Example responses

> 200 Response

    {
      "board_cards_count": 0
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» board_cards_count | integer | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## get_all_cards

> Code samples

    # You can also use wget
    curl -X GET /api/boards/{board}/lists/{list}/cards \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    GET /api/boards/{board}/lists/{list}/cards HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/lists/{list}/cards',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/lists/{list}/cards',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.get '/api/boards/{board}/lists/{list}/cards',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.get('/api/boards/{board}/lists/{list}/cards', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/lists/{list}/cards");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("GET");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("GET", "/api/boards/{board}/lists/{list}/cards", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('GET','/api/boards/{board}/lists/{list}/cards', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`GET /api/boards/{board}/lists/{list}/cards`

Get all Cards attached to a List

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID
list | path | string | true | the list ID

#### Detailed descriptions

board: the board ID

list: the list ID

> Example responses

> 200 Response

    [
      {
        "_id": "string",
        "title": "string",
        "description": "string"
      }
    ]

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none
» title | string | false | none | none
» description | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## new_card

> Code samples

    # You can also use wget
    curl -X POST /api/boards/{board}/lists/{list}/cards \
      -H 'Content-Type: multipart/form-data' \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    POST /api/boards/{board}/lists/{list}/cards HTTP/1.1

    Content-Type: multipart/form-data
    Accept: application/json

    const inputBody = '{
      "authorId": "string",
      "members": "string",
      "assignees": "string",
      "title": "string",
      "description": "string",
      "swimlaneId": "string"
    }';
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/lists/{list}/cards',
    {
      method: 'POST',
      body: inputBody,
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');
    const inputBody = {
      "authorId": "string",
      "members": "string",
      "assignees": "string",
      "title": "string",
      "description": "string",
      "swimlaneId": "string"
    };
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/lists/{list}/cards',
    {
      method: 'POST',
      body: JSON.stringify(inputBody),
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Content-Type' => 'multipart/form-data',
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.post '/api/boards/{board}/lists/{list}/cards',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Content-Type': 'multipart/form-data',
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.post('/api/boards/{board}/lists/{list}/cards', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/lists/{list}/cards");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("POST");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Content-Type": []string{"multipart/form-data"},
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("POST", "/api/boards/{board}/lists/{list}/cards", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'multipart/form-data',
        'Accept' => 'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('POST','/api/boards/{board}/lists/{list}/cards', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`POST /api/boards/{board}/lists/{list}/cards`

Create a new Card

> Body parameter

    authorId: string
    members: string
    assignees: string
    title: string
    description: string
    swimlaneId: string

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID of the new card
list | path | string | true | the list ID of the new card
body | body | object | true | none
» authorId | body | string | true | the authorId value
» members | body | string | false | the member IDs list of the new card
» assignees | body | string | false | the assignee IDs list of the new card
» title | body | string | true | the title of the new card
» description | body | string | true | the description of the new card
» swimlaneId | body | string | true | the swimlane ID of the new card

#### Detailed descriptions

board: the board ID of the new card

list: the list ID of the new card

> Example responses

> 200 Response

    {
      "_id": "string"
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## get_card

> Code samples

    # You can also use wget
    curl -X GET /api/boards/{board}/lists/{list}/cards/{card} \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    GET /api/boards/{board}/lists/{list}/cards/{card} HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/lists/{list}/cards/{card}',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/lists/{list}/cards/{card}',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.get '/api/boards/{board}/lists/{list}/cards/{card}',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.get('/api/boards/{board}/lists/{list}/cards/{card}', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/lists/{list}/cards/{card}");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("GET");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("GET", "/api/boards/{board}/lists/{list}/cards/{card}", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('GET','/api/boards/{board}/lists/{list}/cards/{card}', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`GET /api/boards/{board}/lists/{list}/cards/{card}`

Get a Card

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID
list | path | string | true | the list ID of the card
card | path | string | true | the card ID

#### Detailed descriptions

board: the board ID

list: the list ID of the card

card: the card ID

> Example responses

> 200 Response

    {
      "title": "string",
      "archived": true,
      "archivedAt": "string",
      "parentId": "string",
      "listId": "string",
      "swimlaneId": "string",
      "boardId": "string",
      "coverId": "string",
      "color": "white",
      "createdAt": "string",
      "modifiedAt": "string",
      "customFields": [
        {}
      ],
      "dateLastActivity": "string",
      "description": "string",
      "requestedBy": "string",
      "assignedBy": "string",
      "labelIds": [
        "string"
      ],
      "members": [
        "string"
      ],
      "assignees": [
        "string"
      ],
      "receivedAt": "string",
      "startAt": "string",
      "dueAt": "string",
      "endAt": "string",
      "spentTime": 0,
      "isOvertime": true,
      "userId": "string",
      "sort": 0,
      "subtaskSort": 0,
      "type": "string",
      "linkedId": "string",
      "vote": {
        "question": "string",
        "positive": [
          "string"
        ],
        "negative": [
          "string"
        ],
        "end": "string",
        "public": true,
        "allowNonBoardMembers": true
      },
      "poker": {
        "question": true,
        "one": [
          "string"
        ],
        "two": [
          "string"
        ],
        "three": [
          "string"
        ],
        "five": [
          "string"
        ],
        "eight": [
          "string"
        ],
        "thirteen": [
          "string"
        ],
        "twenty": [
          "string"
        ],
        "forty": [
          "string"
        ],
        "oneHundred": [
          "string"
        ],
        "unsure": [
          "string"
        ],
        "end": "string",
        "allowNonBoardMembers": true,
        "estimation": 0
      },
      "targetId_gantt": [
        "string"
      ],
      "linkType_gantt": [
        0
      ],
      "linkId_gantt": [
        "string"
      ],
      "cardNumber": 0
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Cards

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## edit_card

> Code samples

    # You can also use wget
    curl -X PUT /api/boards/{board}/lists/{list}/cards/{card} \
      -H 'Content-Type: multipart/form-data' \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    PUT /api/boards/{board}/lists/{list}/cards/{card} HTTP/1.1

    Content-Type: multipart/form-data
    Accept: application/json

    const inputBody = '{
      "newBoardId": "string",
      "newSwimlaneId": "string",
      "newListId": "string",
      "title": "string",
      "sort": "string",
      "parentId": "string",
      "description": "string",
      "color": "string",
      "vote": {},
      "poker": {},
      "labelIds": "string",
      "requestedBy": "string",
      "assignedBy": "string",
      "receivedAt": "string",
      "startAt": "string",
      "dueAt": "string",
      "endAt": "string",
      "spentTime": "string",
      "isOverTime": true,
      "customFields": "string",
      "members": "string",
      "assignees": "string",
      "swimlaneId": "string",
      "listId": "string",
      "authorId": "string",
      "archive": "string"
    }';
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/lists/{list}/cards/{card}',
    {
      method: 'PUT',
      body: inputBody,
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');
    const inputBody = {
      "newBoardId": "string",
      "newSwimlaneId": "string",
      "newListId": "string",
      "title": "string",
      "sort": "string",
      "parentId": "string",
      "description": "string",
      "color": "string",
      "vote": {},
      "poker": {},
      "labelIds": "string",
      "requestedBy": "string",
      "assignedBy": "string",
      "receivedAt": "string",
      "startAt": "string",
      "dueAt": "string",
      "endAt": "string",
      "spentTime": "string",
      "isOverTime": true,
      "customFields": "string",
      "members": "string",
      "assignees": "string",
      "swimlaneId": "string",
      "listId": "string",
      "authorId": "string",
      "archive": "string"
    };
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/lists/{list}/cards/{card}',
    {
      method: 'PUT',
      body: JSON.stringify(inputBody),
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Content-Type' => 'multipart/form-data',
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.put '/api/boards/{board}/lists/{list}/cards/{card}',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Content-Type': 'multipart/form-data',
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.put('/api/boards/{board}/lists/{list}/cards/{card}', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/lists/{list}/cards/{card}");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("PUT");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Content-Type": []string{"multipart/form-data"},
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("PUT", "/api/boards/{board}/lists/{list}/cards/{card}", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'multipart/form-data',
        'Accept' => 'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('PUT','/api/boards/{board}/lists/{list}/cards/{card}', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`PUT /api/boards/{board}/lists/{list}/cards/{card}`

Edit Fields in a Card

Edit a card

The color has to be chosen between `white`, `green`, `yellow`, `orange`, `red`, `purple`, `blue`, `sky`, `lime`, `pink`, `black`, `silver`, `peachpuff`, `crimson`, `plum`, `darkgreen`, `slateblue`, `magenta`, `gold`, `navy`, `gray`, `saddlebrown`, `paleturquoise`, `mistyrose`, `indigo`:

Note: setting the color to white has the same effect than removing it.

> Body parameter

    newBoardId: string
    newSwimlaneId: string
    newListId: string
    title: string
    sort: string
    parentId: string
    description: string
    color: string
    vote: {}
    poker: {}
    labelIds: string
    requestedBy: string
    assignedBy: string
    receivedAt: string
    startAt: string
    dueAt: string
    endAt: string
    spentTime: string
    isOverTime: true
    customFields: string
    members: string
    assignees: string
    swimlaneId: string
    listId: string
    authorId: string
    archive: string

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID of the card
list | path | string | true | the list ID of the card
card | path | string | true | the ID of the card
body | body | object | true | none
» newBoardId | body | string | true | the newBoardId value
» newSwimlaneId | body | string | true | the newSwimlaneId value
» newListId | body | string | true | the newListId value
» title | body | string | false | the new title of the card
» sort | body | string | false | the new sort value of the card
» parentId | body | string | false | change the parent of the card
» description | body | string | false | the new description of the card
» color | body | string | false | the new color of the card
» vote | body | object | false | the vote object
» poker | body | object | false | the poker object
» labelIds | body | string | false | the new list of label IDs attached to the card
» requestedBy | body | string | false | the new requestedBy field of the card
» assignedBy | body | string | false | the new assignedBy field of the card
» receivedAt | body | string | false | the new receivedAt field of the card
» startAt | body | string | false | the new startAt field of the card
» dueAt | body | string | false | the new dueAt field of the card
» endAt | body | string | false | the new endAt field of the card
» spentTime | body | string | false | the new spentTime field of the card
» isOverTime | body | boolean | false | the new isOverTime field of the card
» customFields | body | string | false | the new customFields value of the card
» members | body | string | false | the new list of member IDs attached to the card
» assignees | body | string | false | the array of maximum one ID of assignee attached to the card
» swimlaneId | body | string | false | the new swimlane ID of the card
» listId | body | string | false | the new list ID of the card (move operation)
» authorId | body | string | false | change the owner of the card
» archive | body | string | true | the archive value

#### Detailed descriptions

board: the board ID of the card

list: the list ID of the card

card: the ID of the card

> Example responses

> 200 Response

    {
      "_id": "string"
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## delete_card

> Code samples

    # You can also use wget
    curl -X DELETE /api/boards/{board}/lists/{list}/cards/{card} \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    DELETE /api/boards/{board}/lists/{list}/cards/{card} HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/lists/{list}/cards/{card}',
    {
      method: 'DELETE',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/lists/{list}/cards/{card}',
    {
      method: 'DELETE',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.delete '/api/boards/{board}/lists/{list}/cards/{card}',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.delete('/api/boards/{board}/lists/{list}/cards/{card}', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/lists/{list}/cards/{card}");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("DELETE");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("DELETE", "/api/boards/{board}/lists/{list}/cards/{card}", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('DELETE','/api/boards/{board}/lists/{list}/cards/{card}', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`DELETE /api/boards/{board}/lists/{list}/cards/{card}`

Delete a card from a board

This operation deletes a card, and therefore the card is not put in the recycle bin.

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID of the card
list | path | string | true | the list ID of the card
card | path | string | true | the ID of the card

#### Detailed descriptions

board: the board ID of the card

list: the list ID of the card

card: the ID of the card

> Example responses

> 200 Response

    {
      "_id": "string"
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## edit_card_custom_field

> Code samples

    # You can also use wget
    curl -X POST /api/boards/{board}/lists/{list}/cards/{card}/customFields/{customField} \
      -H 'Content-Type: multipart/form-data' \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    POST /api/boards/{board}/lists/{list}/cards/{card}/customFields/{customField} HTTP/1.1

    Content-Type: multipart/form-data
    Accept: application/json

    const inputBody = '{
      "value": "string"
    }';
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/lists/{list}/cards/{card}/customFields/{customField}',
    {
      method: 'POST',
      body: inputBody,
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');
    const inputBody = {
      "value": "string"
    };
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/lists/{list}/cards/{card}/customFields/{customField}',
    {
      method: 'POST',
      body: JSON.stringify(inputBody),
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Content-Type' => 'multipart/form-data',
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.post '/api/boards/{board}/lists/{list}/cards/{card}/customFields/{customField}',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Content-Type': 'multipart/form-data',
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.post('/api/boards/{board}/lists/{list}/cards/{card}/customFields/{customField}', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/lists/{list}/cards/{card}/customFields/{customField}");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("POST");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Content-Type": []string{"multipart/form-data"},
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("POST", "/api/boards/{board}/lists/{list}/cards/{card}/customFields/{customField}", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'multipart/form-data',
        'Accept' => 'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('POST','/api/boards/{board}/lists/{list}/cards/{card}/customFields/{customField}', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`POST /api/boards/{board}/lists/{list}/cards/{card}/customFields/{customField}`

Edit Custom Field in a Card

Edit a custom field value in a card

> Body parameter

    value: string

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID of the card
list | path | string | true | the list ID of the card
card | path | string | true | the ID of the card
customField | path | string | true | the ID of the custom field
body | body | object | true | none
» value | body | string | true | the new custom field value

#### Detailed descriptions

board: the board ID of the card

list: the list ID of the card

card: the ID of the card

customField: the ID of the custom field

> Example responses

> 200 Response

    {
      "_id": "string",
      "customFields": {}
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none
» customFields | object | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## get_list_cards_count

> Code samples

    # You can also use wget
    curl -X GET /api/boards/{board}/lists/{list}/cards_count \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    GET /api/boards/{board}/lists/{list}/cards_count HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/lists/{list}/cards_count',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/lists/{list}/cards_count',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.get '/api/boards/{board}/lists/{list}/cards_count',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.get('/api/boards/{board}/lists/{list}/cards_count', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/lists/{list}/cards_count");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("GET");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("GET", "/api/boards/{board}/lists/{list}/cards_count", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('GET','/api/boards/{board}/lists/{list}/cards_count', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`GET /api/boards/{board}/lists/{list}/cards_count`

Get a cards count to a list

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID
list | path | string | true | the List ID

#### Detailed descriptions

board: the board ID

list: the List ID

> Example responses

> 200 Response

    {
      "list_cards_count": 0
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» list_cards_count | integer | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## get_swimlane_cards

> Code samples

    # You can also use wget
    curl -X GET /api/boards/{board}/swimlanes/{swimlane}/cards \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    GET /api/boards/{board}/swimlanes/{swimlane}/cards HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/swimlanes/{swimlane}/cards',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/swimlanes/{swimlane}/cards',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.get '/api/boards/{board}/swimlanes/{swimlane}/cards',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.get('/api/boards/{board}/swimlanes/{swimlane}/cards', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/swimlanes/{swimlane}/cards");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("GET");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("GET", "/api/boards/{board}/swimlanes/{swimlane}/cards", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('GET','/api/boards/{board}/swimlanes/{swimlane}/cards', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`GET /api/boards/{board}/swimlanes/{swimlane}/cards`

get all cards attached to a swimlane

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID
swimlane | path | string | true | the swimlane ID

#### Detailed descriptions

board: the board ID

swimlane: the swimlane ID

> Example responses

> 200 Response

    [
      {
        "_id": "string",
        "title": "string",
        "description": "string",
        "listId": "string"
      }
    ]

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none
» title | string | false | none | none
» description | string | false | none | none
» listId | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

# CustomFields

## get_all_custom_fields

> Code samples

    # You can also use wget
    curl -X GET /api/boards/{board}/custom-fields \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    GET /api/boards/{board}/custom-fields HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/custom-fields',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/custom-fields',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.get '/api/boards/{board}/custom-fields',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.get('/api/boards/{board}/custom-fields', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/custom-fields");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("GET");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("GET", "/api/boards/{board}/custom-fields", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('GET','/api/boards/{board}/custom-fields', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`GET /api/boards/{board}/custom-fields`

Get the list of Custom Fields attached to a board

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board value

> Example responses

> 200 Response

    [
      {
        "_id": "string",
        "name": "string",
        "type": "string"
      }
    ]

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none
» name | string | false | none | none
» type | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## new_custom_field

> Code samples

    # You can also use wget
    curl -X POST /api/boards/{board}/custom-fields \
      -H 'Content-Type: multipart/form-data' \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    POST /api/boards/{board}/custom-fields HTTP/1.1

    Content-Type: multipart/form-data
    Accept: application/json

    const inputBody = '{
      "name": "string",
      "type": "string",
      "settings": "string",
      "showOnCard": true,
      "automaticallyOnCard": true,
      "showLabelOnMiniCard": true,
      "showSumAtTopOfList": true,
      "authorId": "string"
    }';
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/custom-fields',
    {
      method: 'POST',
      body: inputBody,
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');
    const inputBody = {
      "name": "string",
      "type": "string",
      "settings": "string",
      "showOnCard": true,
      "automaticallyOnCard": true,
      "showLabelOnMiniCard": true,
      "showSumAtTopOfList": true,
      "authorId": "string"
    };
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/custom-fields',
    {
      method: 'POST',
      body: JSON.stringify(inputBody),
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Content-Type' => 'multipart/form-data',
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.post '/api/boards/{board}/custom-fields',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Content-Type': 'multipart/form-data',
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.post('/api/boards/{board}/custom-fields', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/custom-fields");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("POST");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Content-Type": []string{"multipart/form-data"},
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("POST", "/api/boards/{board}/custom-fields", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'multipart/form-data',
        'Accept' => 'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('POST','/api/boards/{board}/custom-fields', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`POST /api/boards/{board}/custom-fields`

Create a Custom Field

> Body parameter

    name: string
    type: string
    settings: string
    showOnCard: true
    automaticallyOnCard: true
    showLabelOnMiniCard: true
    showSumAtTopOfList: true
    authorId: string

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board value
body | body | object | true | none
» name | body | string | true | the name of the custom field
» type | body | string | true | the type of the custom field
» settings | body | string | true | the settings object of the custom field
» showOnCard | body | boolean | true | should we show the custom field on cards?
» automaticallyOnCard | body | boolean | true | should the custom fields automatically be added on cards?
» showLabelOnMiniCard | body | boolean | true | should the label of the custom field be shown on minicards?
» showSumAtTopOfList | body | boolean | true | should the sum of the custom fields be shown at top of list?
» authorId | body | string | true | the authorId value

> Example responses

> 200 Response

    {
      "_id": "string"
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## get_custom_field

> Code samples

    # You can also use wget
    curl -X GET /api/boards/{board}/custom-fields/{customField} \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    GET /api/boards/{board}/custom-fields/{customField} HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/custom-fields/{customField}',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/custom-fields/{customField}',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.get '/api/boards/{board}/custom-fields/{customField}',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.get('/api/boards/{board}/custom-fields/{customField}', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/custom-fields/{customField}");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("GET");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("GET", "/api/boards/{board}/custom-fields/{customField}", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('GET','/api/boards/{board}/custom-fields/{customField}', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`GET /api/boards/{board}/custom-fields/{customField}`

Get a Custom Fields attached to a board

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board value
customField | path | string | true | the ID of the custom field

#### Detailed descriptions

customField: the ID of the custom field

> Example responses

> 200 Response

    [
      {
        "_id": "string",
        "boardIds": "string"
      }
    ]

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none
» boardIds | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## edit_custom_field

> Code samples

    # You can also use wget
    curl -X PUT /api/boards/{board}/custom-fields/{customField} \
      -H 'Content-Type: multipart/form-data' \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    PUT /api/boards/{board}/custom-fields/{customField} HTTP/1.1

    Content-Type: multipart/form-data
    Accept: application/json

    const inputBody = '{
      "name": "string",
      "type": "string",
      "settings": "string",
      "showOnCard": true,
      "automaticallyOnCard": true,
      "alwaysOnCard": "string",
      "showLabelOnMiniCard": true,
      "showSumAtTopOfList": true
    }';
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/custom-fields/{customField}',
    {
      method: 'PUT',
      body: inputBody,
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');
    const inputBody = {
      "name": "string",
      "type": "string",
      "settings": "string",
      "showOnCard": true,
      "automaticallyOnCard": true,
      "alwaysOnCard": "string",
      "showLabelOnMiniCard": true,
      "showSumAtTopOfList": true
    };
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/custom-fields/{customField}',
    {
      method: 'PUT',
      body: JSON.stringify(inputBody),
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Content-Type' => 'multipart/form-data',
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.put '/api/boards/{board}/custom-fields/{customField}',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Content-Type': 'multipart/form-data',
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.put('/api/boards/{board}/custom-fields/{customField}', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/custom-fields/{customField}");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("PUT");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Content-Type": []string{"multipart/form-data"},
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("PUT", "/api/boards/{board}/custom-fields/{customField}", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'multipart/form-data',
        'Accept' => 'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('PUT','/api/boards/{board}/custom-fields/{customField}', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`PUT /api/boards/{board}/custom-fields/{customField}`

Update a Custom Field

> Body parameter

    name: string
    type: string
    settings: string
    showOnCard: true
    automaticallyOnCard: true
    alwaysOnCard: string
    showLabelOnMiniCard: true
    showSumAtTopOfList: true

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board value
customField | path | string | true | the customField value
body | body | object | true | none
» name | body | string | true | the name of the custom field
» type | body | string | true | the type of the custom field
» settings | body | string | true | the settings object of the custom field
» showOnCard | body | boolean | true | should we show the custom field on cards
» automaticallyOnCard | body | boolean | true | should the custom fields automatically be added on cards
» alwaysOnCard | body | string | true | the alwaysOnCard value
» showLabelOnMiniCard | body | boolean | true | should the label of the custom field be shown on minicards
» showSumAtTopOfList | body | boolean | true | should the sum of the custom fields be shown at top of list

> Example responses

> 200 Response

    {
      "_id": "string"
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## delete_custom_field

> Code samples

    # You can also use wget
    curl -X DELETE /api/boards/{board}/custom-fields/{customField} \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    DELETE /api/boards/{board}/custom-fields/{customField} HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/custom-fields/{customField}',
    {
      method: 'DELETE',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/custom-fields/{customField}',
    {
      method: 'DELETE',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.delete '/api/boards/{board}/custom-fields/{customField}',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.delete('/api/boards/{board}/custom-fields/{customField}', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/custom-fields/{customField}");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("DELETE");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("DELETE", "/api/boards/{board}/custom-fields/{customField}", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('DELETE','/api/boards/{board}/custom-fields/{customField}', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`DELETE /api/boards/{board}/custom-fields/{customField}`

Delete a Custom Fields attached to a board

The Custom Field can't be retrieved after this operation

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board value
customField | path | string | true | the ID of the custom field

#### Detailed descriptions

customField: the ID of the custom field

> Example responses

> 200 Response

    {
      "_id": "string"
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## add_custom_field_dropdown_items

> Code samples

    # You can also use wget
    curl -X POST /api/boards/{board}/custom-fields/{customField}/dropdown-items \
      -H 'Content-Type: multipart/form-data' \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    POST /api/boards/{board}/custom-fields/{customField}/dropdown-items HTTP/1.1

    Content-Type: multipart/form-data
    Accept: application/json

    const inputBody = '{
      "items": "string"
    }';
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/custom-fields/{customField}/dropdown-items',
    {
      method: 'POST',
      body: inputBody,
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');
    const inputBody = {
      "items": "string"
    };
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/custom-fields/{customField}/dropdown-items',
    {
      method: 'POST',
      body: JSON.stringify(inputBody),
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Content-Type' => 'multipart/form-data',
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.post '/api/boards/{board}/custom-fields/{customField}/dropdown-items',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Content-Type': 'multipart/form-data',
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.post('/api/boards/{board}/custom-fields/{customField}/dropdown-items', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/custom-fields/{customField}/dropdown-items");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("POST");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Content-Type": []string{"multipart/form-data"},
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("POST", "/api/boards/{board}/custom-fields/{customField}/dropdown-items", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'multipart/form-data',
        'Accept' => 'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('POST','/api/boards/{board}/custom-fields/{customField}/dropdown-items', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`POST /api/boards/{board}/custom-fields/{customField}/dropdown-items`

Update a Custom Field's dropdown items

> Body parameter

    items: string

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board value
customField | path | string | true | the customField value
body | body | object | false | none
» items | body | string | false | names of the custom field

> Example responses

> 200 Response

    {
      "_id": "string"
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## edit_custom_field_dropdown_item

> Code samples

    # You can also use wget
    curl -X PUT /api/boards/{board}/custom-fields/{customField}/dropdown-items/{dropdownItem} \
      -H 'Content-Type: multipart/form-data' \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    PUT /api/boards/{board}/custom-fields/{customField}/dropdown-items/{dropdownItem} HTTP/1.1

    Content-Type: multipart/form-data
    Accept: application/json

    const inputBody = '{
      "name": "string"
    }';
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/custom-fields/{customField}/dropdown-items/{dropdownItem}',
    {
      method: 'PUT',
      body: inputBody,
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');
    const inputBody = {
      "name": "string"
    };
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/custom-fields/{customField}/dropdown-items/{dropdownItem}',
    {
      method: 'PUT',
      body: JSON.stringify(inputBody),
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Content-Type' => 'multipart/form-data',
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.put '/api/boards/{board}/custom-fields/{customField}/dropdown-items/{dropdownItem}',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Content-Type': 'multipart/form-data',
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.put('/api/boards/{board}/custom-fields/{customField}/dropdown-items/{dropdownItem}', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/custom-fields/{customField}/dropdown-items/{dropdownItem}");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("PUT");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Content-Type": []string{"multipart/form-data"},
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("PUT", "/api/boards/{board}/custom-fields/{customField}/dropdown-items/{dropdownItem}", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'multipart/form-data',
        'Accept' => 'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('PUT','/api/boards/{board}/custom-fields/{customField}/dropdown-items/{dropdownItem}', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`PUT /api/boards/{board}/custom-fields/{customField}/dropdown-items/{dropdownItem}`

Update a Custom Field's dropdown item

> Body parameter

    name: string

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board value
customField | path | string | true | the customField value
dropdownItem | path | string | true | the dropdownItem value
body | body | object | true | none
» name | body | string | true | names of the custom field

> Example responses

> 200 Response

    {
      "_id": "string"
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## delete_custom_field_dropdown_item

> Code samples

    # You can also use wget
    curl -X DELETE /api/boards/{board}/custom-fields/{customField}/dropdown-items/{dropdownItem} \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    DELETE /api/boards/{board}/custom-fields/{customField}/dropdown-items/{dropdownItem} HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/custom-fields/{customField}/dropdown-items/{dropdownItem}',
    {
      method: 'DELETE',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/custom-fields/{customField}/dropdown-items/{dropdownItem}',
    {
      method: 'DELETE',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.delete '/api/boards/{board}/custom-fields/{customField}/dropdown-items/{dropdownItem}',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.delete('/api/boards/{board}/custom-fields/{customField}/dropdown-items/{dropdownItem}', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/custom-fields/{customField}/dropdown-items/{dropdownItem}");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("DELETE");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("DELETE", "/api/boards/{board}/custom-fields/{customField}/dropdown-items/{dropdownItem}", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('DELETE','/api/boards/{board}/custom-fields/{customField}/dropdown-items/{dropdownItem}', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`DELETE /api/boards/{board}/custom-fields/{customField}/dropdown-items/{dropdownItem}`

Update a Custom Field's dropdown items

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board value
customField | path | string | true | the customField value
dropdownItem | path | string | true | the dropdownItem value

> Example responses

> 200 Response

    {
      "_id": "string"
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

# Integrations

## get_all_integrations

> Code samples

    # You can also use wget
    curl -X GET /api/boards/{board}/integrations \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    GET /api/boards/{board}/integrations HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/integrations',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/integrations',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.get '/api/boards/{board}/integrations',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.get('/api/boards/{board}/integrations', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/integrations");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("GET");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("GET", "/api/boards/{board}/integrations", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('GET','/api/boards/{board}/integrations', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`GET /api/boards/{board}/integrations`

Get all integrations in board

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID

#### Detailed descriptions

board: the board ID

> Example responses

> 200 Response

    [
      {
        "enabled": true,
        "title": "string",
        "type": "string",
        "activities": [
          "string"
        ],
        "url": "string",
        "token": "string",
        "boardId": "string",
        "createdAt": "string",
        "modifiedAt": "string",
        "userId": "string"
      }
    ]

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
anonymous | [Integrations] | false | none | [Integration with third-party applications]
» enabled | boolean | true | none | is the integration enabled?
» title | string¦null | false | none | name of the integration
» type | string | true | none | type of the integratation (Default to 'outgoing-webhooks')
» activities | [string] | true | none | activities the integration gets triggered (list)
» url | string | true | none | none
» token | string¦null | false | none | token of the integration
» boardId | string | true | none | Board ID of the integration
» createdAt | string | true | none | Creation date of the integration
» modifiedAt | string | true | none | none
» userId | string | true | none | user ID who created the interation

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## new_integration

> Code samples

    # You can also use wget
    curl -X POST /api/boards/{board}/integrations \
      -H 'Content-Type: multipart/form-data' \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    POST /api/boards/{board}/integrations HTTP/1.1

    Content-Type: multipart/form-data
    Accept: application/json

    const inputBody = '{
      "url": "string"
    }';
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/integrations',
    {
      method: 'POST',
      body: inputBody,
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');
    const inputBody = {
      "url": "string"
    };
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/integrations',
    {
      method: 'POST',
      body: JSON.stringify(inputBody),
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Content-Type' => 'multipart/form-data',
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.post '/api/boards/{board}/integrations',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Content-Type': 'multipart/form-data',
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.post('/api/boards/{board}/integrations', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/integrations");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("POST");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Content-Type": []string{"multipart/form-data"},
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("POST", "/api/boards/{board}/integrations", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'multipart/form-data',
        'Accept' => 'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('POST','/api/boards/{board}/integrations', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`POST /api/boards/{board}/integrations`

Create a new integration

> Body parameter

    url: string

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID
body | body | object | true | none
» url | body | string | true | the URL of the integration

#### Detailed descriptions

board: the board ID

> Example responses

> 200 Response

    {
      "_id": "string"
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## get_integration

> Code samples

    # You can also use wget
    curl -X GET /api/boards/{board}/integrations/{int} \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    GET /api/boards/{board}/integrations/{int} HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/integrations/{int}',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/integrations/{int}',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.get '/api/boards/{board}/integrations/{int}',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.get('/api/boards/{board}/integrations/{int}', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/integrations/{int}");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("GET");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("GET", "/api/boards/{board}/integrations/{int}", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('GET','/api/boards/{board}/integrations/{int}', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`GET /api/boards/{board}/integrations/{int}`

Get a single integration in board

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID
int | path | string | true | the integration ID

#### Detailed descriptions

board: the board ID

int: the integration ID

> Example responses

> 200 Response

    {
      "enabled": true,
      "title": "string",
      "type": "string",
      "activities": [
        "string"
      ],
      "url": "string",
      "token": "string",
      "boardId": "string",
      "createdAt": "string",
      "modifiedAt": "string",
      "userId": "string"
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Integrations

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## edit_integration

> Code samples

    # You can also use wget
    curl -X PUT /api/boards/{board}/integrations/{int} \
      -H 'Content-Type: multipart/form-data' \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    PUT /api/boards/{board}/integrations/{int} HTTP/1.1

    Content-Type: multipart/form-data
    Accept: application/json

    const inputBody = '{
      "enabled": "string",
      "title": "string",
      "url": "string",
      "token": "string",
      "activities": "string"
    }';
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/integrations/{int}',
    {
      method: 'PUT',
      body: inputBody,
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');
    const inputBody = {
      "enabled": "string",
      "title": "string",
      "url": "string",
      "token": "string",
      "activities": "string"
    };
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/integrations/{int}',
    {
      method: 'PUT',
      body: JSON.stringify(inputBody),
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Content-Type' => 'multipart/form-data',
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.put '/api/boards/{board}/integrations/{int}',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Content-Type': 'multipart/form-data',
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.put('/api/boards/{board}/integrations/{int}', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/integrations/{int}");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("PUT");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Content-Type": []string{"multipart/form-data"},
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("PUT", "/api/boards/{board}/integrations/{int}", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'multipart/form-data',
        'Accept' => 'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('PUT','/api/boards/{board}/integrations/{int}', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`PUT /api/boards/{board}/integrations/{int}`

Edit integration data

> Body parameter

    enabled: string
    title: string
    url: string
    token: string
    activities: string

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID
int | path | string | true | the integration ID
body | body | object | false | none
» enabled | body | string | false | is the integration enabled?
» title | body | string | false | new name of the integration
» url | body | string | false | new URL of the integration
» token | body | string | false | new token of the integration
» activities | body | string | false | new list of activities of the integration

#### Detailed descriptions

board: the board ID

int: the integration ID

> Example responses

> 200 Response

    {
      "_id": "string"
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## delete_integration

> Code samples

    # You can also use wget
    curl -X DELETE /api/boards/{board}/integrations/{int} \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    DELETE /api/boards/{board}/integrations/{int} HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/integrations/{int}',
    {
      method: 'DELETE',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/integrations/{int}',
    {
      method: 'DELETE',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.delete '/api/boards/{board}/integrations/{int}',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.delete('/api/boards/{board}/integrations/{int}', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/integrations/{int}");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("DELETE");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("DELETE", "/api/boards/{board}/integrations/{int}", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('DELETE','/api/boards/{board}/integrations/{int}', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`DELETE /api/boards/{board}/integrations/{int}`

Delete integration

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID
int | path | string | true | the integration ID

#### Detailed descriptions

board: the board ID

int: the integration ID

> Example responses

> 200 Response

    {
      "_id": "string"
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## delete_integration_activities

> Code samples

    # You can also use wget
    curl -X DELETE /api/boards/{board}/integrations/{int}/activities \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    DELETE /api/boards/{board}/integrations/{int}/activities HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/integrations/{int}/activities',
    {
      method: 'DELETE',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/integrations/{int}/activities',
    {
      method: 'DELETE',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.delete '/api/boards/{board}/integrations/{int}/activities',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.delete('/api/boards/{board}/integrations/{int}/activities', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/integrations/{int}/activities");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("DELETE");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("DELETE", "/api/boards/{board}/integrations/{int}/activities", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('DELETE','/api/boards/{board}/integrations/{int}/activities', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`DELETE /api/boards/{board}/integrations/{int}/activities`

Delete subscribed activities

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID
int | path | string | true | the integration ID

#### Detailed descriptions

board: the board ID

int: the integration ID

> Example responses

> 200 Response

    {
      "enabled": true,
      "title": "string",
      "type": "string",
      "activities": [
        "string"
      ],
      "url": "string",
      "token": "string",
      "boardId": "string",
      "createdAt": "string",
      "modifiedAt": "string",
      "userId": "string"
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Integrations

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## new_integration_activities

> Code samples

    # You can also use wget
    curl -X POST /api/boards/{board}/integrations/{int}/activities \
      -H 'Content-Type: multipart/form-data' \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    POST /api/boards/{board}/integrations/{int}/activities HTTP/1.1

    Content-Type: multipart/form-data
    Accept: application/json

    const inputBody = '{
      "activities": "string"
    }';
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/integrations/{int}/activities',
    {
      method: 'POST',
      body: inputBody,
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');
    const inputBody = {
      "activities": "string"
    };
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/integrations/{int}/activities',
    {
      method: 'POST',
      body: JSON.stringify(inputBody),
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Content-Type' => 'multipart/form-data',
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.post '/api/boards/{board}/integrations/{int}/activities',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Content-Type': 'multipart/form-data',
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.post('/api/boards/{board}/integrations/{int}/activities', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/integrations/{int}/activities");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("POST");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Content-Type": []string{"multipart/form-data"},
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("POST", "/api/boards/{board}/integrations/{int}/activities", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'multipart/form-data',
        'Accept' => 'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('POST','/api/boards/{board}/integrations/{int}/activities', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`POST /api/boards/{board}/integrations/{int}/activities`

Add subscribed activities

> Body parameter

    activities: string

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID
int | path | string | true | the integration ID
body | body | object | true | none
» activities | body | string | true | the activities value

#### Detailed descriptions

board: the board ID

int: the integration ID

> Example responses

> 200 Response

    {
      "enabled": true,
      "title": "string",
      "type": "string",
      "activities": [
        "string"
      ],
      "url": "string",
      "token": "string",
      "boardId": "string",
      "createdAt": "string",
      "modifiedAt": "string",
      "userId": "string"
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Integrations

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

# Lists

## get_all_lists

> Code samples

    # You can also use wget
    curl -X GET /api/boards/{board}/lists \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    GET /api/boards/{board}/lists HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/lists',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/lists',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.get '/api/boards/{board}/lists',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.get('/api/boards/{board}/lists', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/lists");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("GET");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("GET", "/api/boards/{board}/lists", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('GET','/api/boards/{board}/lists', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`GET /api/boards/{board}/lists`

Get the list of Lists attached to a board

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID

#### Detailed descriptions

board: the board ID

> Example responses

> 200 Response

    [
      {
        "_id": "string",
        "title": "string"
      }
    ]

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none
» title | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## new_list

> Code samples

    # You can also use wget
    curl -X POST /api/boards/{board}/lists \
      -H 'Content-Type: multipart/form-data' \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    POST /api/boards/{board}/lists HTTP/1.1

    Content-Type: multipart/form-data
    Accept: application/json

    const inputBody = '{
      "title": "string"
    }';
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/lists',
    {
      method: 'POST',
      body: inputBody,
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');
    const inputBody = {
      "title": "string"
    };
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/lists',
    {
      method: 'POST',
      body: JSON.stringify(inputBody),
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Content-Type' => 'multipart/form-data',
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.post '/api/boards/{board}/lists',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Content-Type': 'multipart/form-data',
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.post('/api/boards/{board}/lists', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/lists");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("POST");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Content-Type": []string{"multipart/form-data"},
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("POST", "/api/boards/{board}/lists", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'multipart/form-data',
        'Accept' => 'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('POST','/api/boards/{board}/lists', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`POST /api/boards/{board}/lists`

Add a List to a board

> Body parameter

    title: string

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID
body | body | object | true | none
» title | body | string | true | the title of the List

#### Detailed descriptions

board: the board ID

> Example responses

> 200 Response

    {
      "_id": "string"
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## get_list

> Code samples

    # You can also use wget
    curl -X GET /api/boards/{board}/lists/{list} \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    GET /api/boards/{board}/lists/{list} HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/lists/{list}',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/lists/{list}',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.get '/api/boards/{board}/lists/{list}',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.get('/api/boards/{board}/lists/{list}', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/lists/{list}");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("GET");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("GET", "/api/boards/{board}/lists/{list}", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('GET','/api/boards/{board}/lists/{list}', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`GET /api/boards/{board}/lists/{list}`

Get a List attached to a board

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID
list | path | string | true | the List ID

#### Detailed descriptions

board: the board ID

list: the List ID

> Example responses

> 200 Response

    {
      "title": "string",
      "starred": true,
      "archived": true,
      "archivedAt": "string",
      "boardId": "string",
      "swimlaneId": "string",
      "createdAt": "string",
      "sort": 0,
      "updatedAt": "string",
      "modifiedAt": "string",
      "wipLimit": {
        "value": 0,
        "enabled": true,
        "soft": true
      },
      "color": "white",
      "type": "string",
      "collapsed": true
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Lists

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## delete_list

> Code samples

    # You can also use wget
    curl -X DELETE /api/boards/{board}/lists/{list} \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    DELETE /api/boards/{board}/lists/{list} HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/lists/{list}',
    {
      method: 'DELETE',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/lists/{list}',
    {
      method: 'DELETE',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.delete '/api/boards/{board}/lists/{list}',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.delete('/api/boards/{board}/lists/{list}', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/lists/{list}");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("DELETE");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("DELETE", "/api/boards/{board}/lists/{list}", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('DELETE','/api/boards/{board}/lists/{list}', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`DELETE /api/boards/{board}/lists/{list}`

Delete a List

This deletes a list from a board. The list is not put in the recycle bin.

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the board ID
list | path | string | true | the ID of the list to remove

#### Detailed descriptions

board: the board ID

list: the ID of the list to remove

> Example responses

> 200 Response

    {
      "_id": "string"
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

# Swimlanes

## get_all_swimlanes

> Code samples

    # You can also use wget
    curl -X GET /api/boards/{board}/swimlanes \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    GET /api/boards/{board}/swimlanes HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/swimlanes',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/swimlanes',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.get '/api/boards/{board}/swimlanes',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.get('/api/boards/{board}/swimlanes', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/swimlanes");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("GET");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("GET", "/api/boards/{board}/swimlanes", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('GET','/api/boards/{board}/swimlanes', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`GET /api/boards/{board}/swimlanes`

Get the list of swimlanes attached to a board

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the ID of the board

#### Detailed descriptions

board: the ID of the board

> Example responses

> 200 Response

    [
      {
        "_id": "string",
        "title": "string"
      }
    ]

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none
» title | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## new_swimlane

> Code samples

    # You can also use wget
    curl -X POST /api/boards/{board}/swimlanes \
      -H 'Content-Type: multipart/form-data' \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    POST /api/boards/{board}/swimlanes HTTP/1.1

    Content-Type: multipart/form-data
    Accept: application/json

    const inputBody = '{
      "title": "string"
    }';
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/swimlanes',
    {
      method: 'POST',
      body: inputBody,
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');
    const inputBody = {
      "title": "string"
    };
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/swimlanes',
    {
      method: 'POST',
      body: JSON.stringify(inputBody),
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Content-Type' => 'multipart/form-data',
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.post '/api/boards/{board}/swimlanes',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Content-Type': 'multipart/form-data',
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.post('/api/boards/{board}/swimlanes', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/swimlanes");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("POST");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Content-Type": []string{"multipart/form-data"},
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("POST", "/api/boards/{board}/swimlanes", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'multipart/form-data',
        'Accept' => 'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('POST','/api/boards/{board}/swimlanes', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`POST /api/boards/{board}/swimlanes`

Add a swimlane to a board

> Body parameter

    title: string

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the ID of the board
body | body | object | true | none
» title | body | string | true | the new title of the swimlane

#### Detailed descriptions

board: the ID of the board

> Example responses

> 200 Response

    {
      "_id": "string"
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## get_swimlane

> Code samples

    # You can also use wget
    curl -X GET /api/boards/{board}/swimlanes/{swimlane} \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    GET /api/boards/{board}/swimlanes/{swimlane} HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/swimlanes/{swimlane}',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/swimlanes/{swimlane}',
    {
      method: 'GET',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.get '/api/boards/{board}/swimlanes/{swimlane}',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.get('/api/boards/{board}/swimlanes/{swimlane}', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/swimlanes/{swimlane}");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("GET");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("GET", "/api/boards/{board}/swimlanes/{swimlane}", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('GET','/api/boards/{board}/swimlanes/{swimlane}', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`GET /api/boards/{board}/swimlanes/{swimlane}`

Get a swimlane

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the ID of the board
swimlane | path | string | true | the ID of the swimlane

#### Detailed descriptions

board: the ID of the board

swimlane: the ID of the swimlane

> Example responses

> 200 Response

    {
      "title": "string",
      "archived": true,
      "archivedAt": "string",
      "boardId": "string",
      "createdAt": "string",
      "sort": 0,
      "color": "white",
      "updatedAt": "string",
      "modifiedAt": "string",
      "type": "string",
      "collapsed": true
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Swimlanes

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## edit_swimlane

> Code samples

    # You can also use wget
    curl -X PUT /api/boards/{board}/swimlanes/{swimlane} \
      -H 'Content-Type: multipart/form-data' \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    PUT /api/boards/{board}/swimlanes/{swimlane} HTTP/1.1

    Content-Type: multipart/form-data
    Accept: application/json

    const inputBody = '{
      "title": "string"
    }';
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/swimlanes/{swimlane}',
    {
      method: 'PUT',
      body: inputBody,
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');
    const inputBody = {
      "title": "string"
    };
    const headers = {
      'Content-Type':'multipart/form-data',
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/swimlanes/{swimlane}',
    {
      method: 'PUT',
      body: JSON.stringify(inputBody),
      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Content-Type' => 'multipart/form-data',
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.put '/api/boards/{board}/swimlanes/{swimlane}',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Content-Type': 'multipart/form-data',
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.put('/api/boards/{board}/swimlanes/{swimlane}', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/swimlanes/{swimlane}");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("PUT");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Content-Type": []string{"multipart/form-data"},
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("PUT", "/api/boards/{board}/swimlanes/{swimlane}", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'multipart/form-data',
        'Accept' => 'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('PUT','/api/boards/{board}/swimlanes/{swimlane}', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`PUT /api/boards/{board}/swimlanes/{swimlane}`

Edit the title of a swimlane

> Body parameter

    title: string

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the ID of the board
swimlane | path | string | true | the ID of the swimlane to edit
body | body | object | true | none
» title | body | string | true | the new title of the swimlane

#### Detailed descriptions

board: the ID of the board

swimlane: the ID of the swimlane to edit

> Example responses

> 200 Response

    {
      "_id": "string"
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

## delete_swimlane

> Code samples

    # You can also use wget
    curl -X DELETE /api/boards/{board}/swimlanes/{swimlane} \
      -H 'Accept: application/json' \
      -H 'Authorization: API_KEY'

    DELETE /api/boards/{board}/swimlanes/{swimlane} HTTP/1.1

    Accept: application/json

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/swimlanes/{swimlane}',
    {
      method: 'DELETE',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    const fetch = require('node-fetch');

    const headers = {
      'Accept':'application/json',
      'Authorization':'API_KEY'
    };

    fetch('/api/boards/{board}/swimlanes/{swimlane}',
    {
      method: 'DELETE',

      headers: headers
    })
    .then(function(res) {
        return res.json();
    }).then(function(body) {
        console.log(body);
    });

    require 'rest-client'
    require 'json'

    headers = {
      'Accept' => 'application/json',
      'Authorization' => 'API_KEY'
    }

    result = RestClient.delete '/api/boards/{board}/swimlanes/{swimlane}',
      params: {
      }, headers: headers

    p JSON.parse(result)

    import requests
    headers = {
      'Accept': 'application/json',
      'Authorization': 'API_KEY'
    }

    r = requests.delete('/api/boards/{board}/swimlanes/{swimlane}', headers = headers)

    print(r.json())

    URL obj = new URL("/api/boards/{board}/swimlanes/{swimlane}");
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("DELETE");
    int responseCode = con.getResponseCode();
    BufferedReader in = new BufferedReader(
        new InputStreamReader(con.getInputStream()));
    String inputLine;
    StringBuffer response = new StringBuffer();
    while ((inputLine = in.readLine()) != null) {
        response.append(inputLine);
    }
    in.close();
    System.out.println(response.toString());

    package main

    import (
           "bytes"
           "net/http"
    )

    func main() {

        headers := map[string][]string{
            "Accept": []string{"application/json"},
            "Authorization": []string{"API_KEY"},
        }

        data := bytes.NewBuffer([]byte{jsonReq})
        req, err := http.NewRequest("DELETE", "/api/boards/{board}/swimlanes/{swimlane}", data)
        req.Header = headers

        client := &http.Client{}
        resp, err := client.Do(req)
        // ...
    }

     'application/json',
        'Authorization' => 'API_KEY',
    );

    $client = new \GuzzleHttp\Client();

    // Define array of request body.
    $request_body = array();

    try {
        $response = $client->request('DELETE','/api/boards/{board}/swimlanes/{swimlane}', array(
            'headers' => $headers,
            'json' => $request_body,
           )
        );
        print_r($response->getBody()->getContents());
     }
     catch (\GuzzleHttp\Exception\BadResponseException $e) {
        // handle exception or api errors.
        print_r($e->getMessage());
     }

     // ...

`DELETE /api/boards/{board}/swimlanes/{swimlane}`

Delete a swimlane

The swimlane will be deleted, not moved to the recycle bin

### Parameters

Name | In | Type | Required | Description
--- | --- | --- | --- | ---
board | path | string | true | the ID of the board
swimlane | path | string | true | the ID of the swimlane

#### Detailed descriptions

board: the ID of the board

swimlane: the ID of the swimlane

> Example responses

> 200 Response

    {
      "_id": "string"
    }

### Responses

Status | Meaning | Description | Schema
--- | --- | --- | ---
200 | OK | 200 response | Inline

### Response Schema

Status Code 200

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
» _id | string | false | none | none

To perform this operation, you must be authenticated by means of one of the following methods: UserSecurity

# Schemas

## Boards

    {
      "title": "string",
      "slug": "string",
      "archived": true,
      "archivedAt": "string",
      "createdAt": "string",
      "modifiedAt": "string",
      "stars": 0,
      "labels": [
        {
          "_id": "string",
          "name": "string",
          "color": "white"
        }
      ],
      "members": [
        {
          "userId": "string",
          "isAdmin": true,
          "isActive": true,
          "isNoComments": true,
          "isCommentOnly": true,
          "isWorker": true
        }
      ],
      "permission": "public",
      "orgs": [
        {
          "orgId": "string",
          "orgDisplayName": "string",
          "isActive": true
        }
      ],
      "teams": [
        {
          "teamId": "string",
          "teamDisplayName": "string",
          "isActive": true
        }
      ],
      "color": "belize",
      "backgroundImageURL": "string",
      "allowsCardCounterList": true,
      "allowsBoardMemberList": true,
      "description": "string",
      "subtasksDefaultBoardId": "string",
      "subtasksDefaultListId": "string",
      "dateSettingsDefaultBoardId": "string",
      "dateSettingsDefaultListId": "string",
      "allowsSubtasks": true,
      "allowsAttachments": true,
      "allowsChecklists": true,
      "allowsComments": true,
      "allowsDescriptionTitle": true,
      "allowsDescriptionText": true,
      "allowsDescriptionTextOnMinicard": true,
      "allowsCoverAttachmentOnMinicard": true,
      "allowsBadgeAttachmentOnMinicard": true,
      "allowsCardSortingByNumberOnMinicard": true,
      "allowsCardNumber": true,
      "allowsActivities": true,
      "allowsLabels": true,
      "allowsCreator": true,
      "allowsCreatorOnMinicard": true,
      "allowsAssignee": true,
      "allowsMembers": true,
      "allowsRequestedBy": true,
      "allowsCardSortingByNumber": true,
      "allowsShowLists": true,
      "allowsAssignedBy": true,
      "allowsReceivedDate": true,
      "allowsStartDate": true,
      "allowsEndDate": true,
      "allowsDueDate": true,
      "presentParentTask": "prefix-with-full-path",
      "receivedAt": "string",
      "startAt": "string",
      "dueAt": "string",
      "endAt": "string",
      "spentTime": 0,
      "isOvertime": true,
      "type": "board",
      "sort": 0
    }

This is a Board.

### Properties

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
title | string | true | none | The title of the board
slug | string | true | none | The title slugified.
archived | boolean | true | none | Is the board archived?
archivedAt | string¦null | false | none | Latest archiving time of the board
createdAt | string | true | none | Creation time of the board
modifiedAt | string¦null | false | none | Last modification time of the board
stars | number | true | none | How many stars the board has
labels | [BoardsLabels]¦null | false | none | List of labels attached to a board
members | [BoardsMembers] | true | none | List of members of a board
permission | string | true | none | visibility of the board
orgs | [BoardsOrgs]¦null | false | none | the list of organizations that a board belongs to
teams | [BoardsTeams]¦null | false | none | the list of teams that a board belongs to
color | string | true | none | The color of the board.
backgroundImageURL | string¦null | false | none | The background image URL of the board.
allowsCardCounterList | boolean | true | none | Show card counter per list
allowsBoardMemberList | boolean | true | none | Show board member list
description | string¦null | false | none | The description of the board
subtasksDefaultBoardId | string¦null | false | none | The default board ID assigned to subtasks.
subtasksDefaultListId | string¦null | false | none | The default List ID assigned to subtasks.
dateSettingsDefaultBoardId | string¦null | false | none | none
dateSettingsDefaultListId | string¦null | false | none | none
allowsSubtasks | boolean | true | none | Does the board allows subtasks?
allowsAttachments | boolean | true | none | Does the board allows attachments?
allowsChecklists | boolean | true | none | Does the board allows checklists?
allowsComments | boolean | true | none | Does the board allows comments?
allowsDescriptionTitle | boolean | true | none | Does the board allows description title?
allowsDescriptionText | boolean | true | none | Does the board allows description text?
allowsDescriptionTextOnMinicard | boolean | true | none | Does the board allows description text on minicard?
allowsCoverAttachmentOnMinicard | boolean | true | none | Does the board allows cover attachment on minicard?
allowsBadgeAttachmentOnMinicard | boolean | true | none | Does the board allows badge attachment on minicard?
allowsCardSortingByNumberOnMinicard | boolean | true | none | Does the board allows card sorting by number on minicard?
allowsCardNumber | boolean | true | none | Does the board allows card numbers?
allowsActivities | boolean | true | none | Does the board allows comments?
allowsLabels | boolean | true | none | Does the board allows labels?
allowsCreator | boolean | true | none | Does the board allow creator?
allowsCreatorOnMinicard | boolean | true | none | Does the board allow creator?
allowsAssignee | boolean | true | none | Does the board allows assignee?
allowsMembers | boolean | true | none | Does the board allows members?
allowsRequestedBy | boolean | true | none | Does the board allows requested by?
allowsCardSortingByNumber | boolean | true | none | Does the board allows card sorting by number?
allowsShowLists | boolean | true | none | Does the board allows show lists on the card?
allowsAssignedBy | boolean | true | none | Does the board allows requested by?
allowsReceivedDate | boolean | true | none | Does the board allows received date?
allowsStartDate | boolean | true | none | Does the board allows start date?
allowsEndDate | boolean | true | none | Does the board allows end date?
allowsDueDate | boolean | true | none | Does the board allows due date?
presentParentTask | string¦null | false | none | Controls how to present the parent task: - `prefix-with-full-path`: add a prefix with the full path - `prefix-with-parent`: add a prefisx with the parent name - `subtext-with-full-path`: add a subtext with the full path - `subtext-with-parent`: add a subtext with the parent name - `no-parent`: does not show the parent at all
receivedAt | string¦null | false | none | Date the card was received
startAt | string¦null | false | none | Starting date of the board.
dueAt | string¦null | false | none | Due date of the board.
endAt | string¦null | false | none | End date of the board.
spentTime | number¦null | false | none | Time spent in the board.
isOvertime | boolean¦null | false | none | Is the board overtimed?
type | string | true | none | The type of board possible values: board, template-board, template-container
sort | number | true | none | Sort value

#### Enumerated Values

Property | Value
--- | ---
permission | public
permission | private
color | belize
color | nephritis
color | pomegranate
color | pumpkin
color | wisteria
color | moderatepink
color | strongcyan
color | limegreen
color | midnight
color | dark
color | relax
color | corteza
color | clearblue
color | natural
color | modern
color | moderndark
color | exodark
color | cleandark
color | cleanlight
presentParentTask | prefix-with-full-path
presentParentTask | prefix-with-parent
presentParentTask | subtext-with-full-path
presentParentTask | subtext-with-parent
presentParentTask | no-parent
type | board
type | template-board
type | template-container

## BoardsLabels

    {
      "_id": "string",
      "name": "string",
      "color": "white"
    }

### Properties

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
_id | string | true | none | Unique id of a label
name | string | false | none | Name of a label
color | string | true | none | color of a label. Can be amongst `green`, `yellow`, `orange`, `red`, `purple`, `blue`, `sky`, `lime`, `pink`, `black`, `silver`, `peachpuff`, `crimson`, `plum`, `darkgreen`, `slateblue`, `magenta`, `gold`, `navy`, `gray`, `saddlebrown`, `paleturquoise`, `mistyrose`, `indigo`

#### Enumerated Values

Property | Value
--- | ---
color | white
color | green
color | yellow
color | orange
color | red
color | purple
color | blue
color | sky
color | lime
color | pink
color | black
color | silver
color | peachpuff
color | crimson
color | plum
color | darkgreen
color | slateblue
color | magenta
color | gold
color | navy
color | gray
color | saddlebrown
color | paleturquoise
color | mistyrose
color | indigo

## BoardsMembers

    {
      "userId": "string",
      "isAdmin": true,
      "isActive": true,
      "isNoComments": true,
      "isCommentOnly": true,
      "isWorker": true
    }

### Properties

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
userId | string | true | none | The uniq ID of the member
isAdmin | boolean | true | none | Is the member an admin of the board?
isActive | boolean | true | none | Is the member active?
isNoComments | boolean | false | none | Is the member not allowed to make comments
isCommentOnly | boolean | false | none | Is the member only allowed to comment on the board
isWorker | boolean | false | none | Is the member only allowed to move card, assign himself to card and comment

## BoardsOrgs

    {
      "orgId": "string",
      "orgDisplayName": "string",
      "isActive": true
    }

### Properties

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
orgId | string | true | none | The uniq ID of the organization
orgDisplayName | string | true | none | The display name of the organization
isActive | boolean | true | none | Is the organization active?

## BoardsTeams

    {
      "teamId": "string",
      "teamDisplayName": "string",
      "isActive": true
    }

### Properties

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
teamId | string | true | none | The uniq ID of the team
teamDisplayName | string | true | none | The display name of the team
isActive | boolean | true | none | Is the team active?

## CardComments

    {
      "boardId": "string",
      "cardId": "string",
      "text": "string",
      "createdAt": "string",
      "modifiedAt": "string",
      "userId": "string"
    }

A comment on a card

### Properties

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
boardId | string | true | none | the board ID
cardId | string | true | none | the card ID
text | string | true | none | the text of the comment
createdAt | string | true | none | when was the comment created
modifiedAt | string | true | none | none
userId | string | true | none | the author ID of the comment

## Cards

    {
      "title": "string",
      "archived": true,
      "archivedAt": "string",
      "parentId": "string",
      "listId": "string",
      "swimlaneId": "string",
      "boardId": "string",
      "coverId": "string",
      "color": "white",
      "createdAt": "string",
      "modifiedAt": "string",
      "customFields": [
        {}
      ],
      "dateLastActivity": "string",
      "description": "string",
      "requestedBy": "string",
      "assignedBy": "string",
      "labelIds": [
        "string"
      ],
      "members": [
        "string"
      ],
      "assignees": [
        "string"
      ],
      "receivedAt": "string",
      "startAt": "string",
      "dueAt": "string",
      "endAt": "string",
      "spentTime": 0,
      "isOvertime": true,
      "userId": "string",
      "sort": 0,
      "subtaskSort": 0,
      "type": "string",
      "linkedId": "string",
      "vote": {
        "question": "string",
        "positive": [
          "string"
        ],
        "negative": [
          "string"
        ],
        "end": "string",
        "public": true,
        "allowNonBoardMembers": true
      },
      "poker": {
        "question": true,
        "one": [
          "string"
        ],
        "two": [
          "string"
        ],
        "three": [
          "string"
        ],
        "five": [
          "string"
        ],
        "eight": [
          "string"
        ],
        "thirteen": [
          "string"
        ],
        "twenty": [
          "string"
        ],
        "forty": [
          "string"
        ],
        "oneHundred": [
          "string"
        ],
        "unsure": [
          "string"
        ],
        "end": "string",
        "allowNonBoardMembers": true,
        "estimation": 0
      },
      "targetId_gantt": [
        "string"
      ],
      "linkType_gantt": [
        0
      ],
      "linkId_gantt": [
        "string"
      ],
      "cardNumber": 0
    }

### Properties

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
title | string¦null | false | none | the title of the card
archived | boolean | true | none | is the card archived
archivedAt | string¦null | false | none | latest archiving date
parentId | string¦null | false | none | ID of the parent card
listId | string¦null | false | none | List ID where the card is
swimlaneId | string | true | none | Swimlane ID where the card is
boardId | string¦null | false | none | Board ID of the card
coverId | string¦null | false | none | Cover ID of the card
color | string¦null | false | none | none
createdAt | string | true | none | creation date
modifiedAt | string | true | none | none
customFields | [CardsCustomfields]¦null | false | none | list of custom fields
dateLastActivity | string | true | none | Date of last activity
description | string¦null | false | none | description of the card
requestedBy | string¦null | false | none | who requested the card (ID of the user)
assignedBy | string¦null | false | none | who assigned the card (ID of the user)
labelIds | [string]¦null | false | none | list of labels ID the card has
members | [string]¦null | false | none | list of members (user IDs)
assignees | [string]¦null | false | none | who is assignee of the card (user ID), maximum one ID of assignee in array.
receivedAt | string¦null | false | none | Date the card was received
startAt | string¦null | false | none | Date the card was started to be worked on
dueAt | string¦null | false | none | Date the card is due
endAt | string¦null | false | none | Date the card ended
spentTime | number¦null | false | none | How much time has been spent on this
isOvertime | boolean¦null | false | none | is the card over time?
userId | string | true | none | user ID of the author of the card
sort | number¦null | false | none | Sort value
subtaskSort | number¦null | false | none | subtask sort value
type | string | true | none | type of the card
linkedId | string¦null | false | none | ID of the linked card
vote | CardsVote | false | none | none
poker | CardsPoker | false | none | none
targetId_gantt | [string]¦null | false | none | ID of card which is the child link in gantt view
linkType_gantt | [number]¦null | false | none | ID of card which is the parent link in gantt view
linkId_gantt | [string]¦null | false | none | ID of card which is the parent link in gantt view
cardNumber | number¦null | false | none | A boardwise sequentially increasing number that is assigned to every newly created card

#### Enumerated Values

Property | Value
--- | ---
color | white
color | green
color | yellow
color | orange
color | red
color | purple
color | blue
color | sky
color | lime
color | pink
color | black
color | silver
color | peachpuff
color | crimson
color | plum
color | darkgreen
color | slateblue
color | magenta
color | gold
color | navy
color | gray
color | saddlebrown
color | paleturquoise
color | mistyrose
color | indigo

## CardsVote

    {
      "question": "string",
      "positive": [
        "string"
      ],
      "negative": [
        "string"
      ],
      "end": "string",
      "public": true,
      "allowNonBoardMembers": true
    }

### Properties

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
question | string | true | none | none
positive | [string] | false | none | list of members (user IDs)
negative | [string] | false | none | list of members (user IDs)
end | string | false | none | none
public | boolean | true | none | none
allowNonBoardMembers | boolean | true | none | none

## CardsPoker

    {
      "question": true,
      "one": [
        "string"
      ],
      "two": [
        "string"
      ],
      "three": [
        "string"
      ],
      "five": [
        "string"
      ],
      "eight": [
        "string"
      ],
      "thirteen": [
        "string"
      ],
      "twenty": [
        "string"
      ],
      "forty": [
        "string"
      ],
      "oneHundred": [
        "string"
      ],
      "unsure": [
        "string"
      ],
      "end": "string",
      "allowNonBoardMembers": true,
      "estimation": 0
    }

### Properties

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
question | boolean | false | none | none
one | [string] | false | none | poker card one
two | [string] | false | none | poker card two
three | [string] | false | none | poker card three
five | [string] | false | none | poker card five
eight | [string] | false | none | poker card eight
thirteen | [string] | false | none | poker card thirteen
twenty | [string] | false | none | poker card twenty
forty | [string] | false | none | poker card forty
oneHundred | [string] | false | none | poker card oneHundred
unsure | [string] | false | none | poker card unsure
end | string | false | none | none
allowNonBoardMembers | boolean | false | none | none
estimation | number | false | none | poker estimation value

## CardsCustomfields

    {}

### Properties

None

## ChecklistItems

    {
      "title": "string",
      "sort": 0,
      "isFinished": true,
      "checklistId": "string",
      "cardId": "string",
      "createdAt": "string",
      "modifiedAt": "string"
    }

An item in a checklist

### Properties

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
title | string | true | none | the text of the item
sort | number | true | none | the sorting field of the item
isFinished | boolean | true | none | Is the item checked?
checklistId | string | true | none | the checklist ID the item is attached to
cardId | string | true | none | the card ID the item is attached to
createdAt | string¦null | false | none | none
modifiedAt | string | true | none | none

## Checklists

    {
      "cardId": "string",
      "title": "string",
      "finishedAt": "string",
      "showAtMinicard": true,
      "createdAt": "string",
      "modifiedAt": "string",
      "sort": 0
    }

A Checklist

### Properties

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
cardId | string | true | none | The ID of the card the checklist is in
title | string | true | none | the title of the checklist
finishedAt | string¦null | false | none | When was the checklist finished
showAtMinicard | boolean¦null | false | none | Show at minicard. Default: false.
createdAt | string | true | none | Creation date of the checklist
modifiedAt | string | true | none | none
sort | number | true | none | sorting value of the checklist

## CustomFields

    {
      "boardIds": [
        "string"
      ],
      "name": "string",
      "type": "text",
      "settings": {
        "currencyCode": "string",
        "dropdownItems": [
          {}
        ],
        "stringtemplateFormat": "string",
        "stringtemplateSeparator": "string"
      },
      "showOnCard": true,
      "automaticallyOnCard": true,
      "alwaysOnCard": true,
      "showLabelOnMiniCard": true,
      "showSumAtTopOfList": true,
      "createdAt": "string",
      "modifiedAt": "string"
    }

A custom field on a card in the board

### Properties

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
boardIds | [string] | true | none | the ID of the board
name | string | true | none | name of the custom field
type | string | true | none | type of the custom field
settings | CustomFieldsSettings | true | none | none
showOnCard | boolean | true | none | should we show on the cards this custom field
automaticallyOnCard | boolean | true | none | should the custom fields automatically be added on cards?
alwaysOnCard | boolean | true | none | should the custom field be automatically added to all cards?
showLabelOnMiniCard | boolean | true | none | should the label of the custom field be shown on minicards?
showSumAtTopOfList | boolean | true | none | should the sum of the custom fields be shown at top of list?
createdAt | string¦null | false | none | none
modifiedAt | string | true | none | none

#### Enumerated Values

Property | Value
--- | ---
type | text
type | number
type | date
type | dropdown
type | checkbox
type | currency
type | stringtemplate

## CustomFieldsSettings

    {
      "currencyCode": "string",
      "dropdownItems": [
        {}
      ],
      "stringtemplateFormat": "string",
      "stringtemplateSeparator": "string"
    }

### Properties

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
currencyCode | string | false | none | none
dropdownItems | [CustomFieldsSettingsDropdownitems] | false | none | list of drop down items objects
stringtemplateFormat | string | false | none | none
stringtemplateSeparator | string | false | none | none

## CustomFieldsSettingsDropdownitems

    {}

### Properties

None

## Integrations

    {
      "enabled": true,
      "title": "string",
      "type": "string",
      "activities": [
        "string"
      ],
      "url": "string",
      "token": "string",
      "boardId": "string",
      "createdAt": "string",
      "modifiedAt": "string",
      "userId": "string"
    }

Integration with third-party applications

### Properties

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
enabled | boolean | true | none | is the integration enabled?
title | string¦null | false | none | name of the integration
type | string | true | none | type of the integratation (Default to 'outgoing-webhooks')
activities | [string] | true | none | activities the integration gets triggered (list)
url | string | true | none | none
token | string¦null | false | none | token of the integration
boardId | string | true | none | Board ID of the integration
createdAt | string | true | none | Creation date of the integration
modifiedAt | string | true | none | none
userId | string | true | none | user ID who created the interation

## Lists

    {
      "title": "string",
      "starred": true,
      "archived": true,
      "archivedAt": "string",
      "boardId": "string",
      "swimlaneId": "string",
      "createdAt": "string",
      "sort": 0,
      "updatedAt": "string",
      "modifiedAt": "string",
      "wipLimit": {
        "value": 0,
        "enabled": true,
        "soft": true
      },
      "color": "white",
      "type": "string",
      "collapsed": true
    }

A list (column) in the Wekan board.

### Properties

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
title | string | true | none | the title of the list
starred | boolean¦null | false | none | if a list is stared then we put it on the top
archived | boolean | true | none | is the list archived
archivedAt | string¦null | false | none | latest archiving date
boardId | string | true | none | the board associated to this list
swimlaneId | string | true | none | the swimlane associated to this list. Used for templates
createdAt | string | true | none | creation date
sort | number¦null | false | none | is the list sorted
updatedAt | string¦null | false | none | last update of the list
modifiedAt | string | true | none | none
wipLimit | ListsWiplimit | false | none | none
color | string¦null | false | none | the color of the list
type | string | true | none | The type of list
collapsed | boolean | true | none | is the list collapsed

#### Enumerated Values

Property | Value
--- | ---
color | white
color | green
color | yellow
color | orange
color | red
color | purple
color | blue
color | sky
color | lime
color | pink
color | black
color | silver
color | peachpuff
color | crimson
color | plum
color | darkgreen
color | slateblue
color | magenta
color | gold
color | navy
color | gray
color | saddlebrown
color | paleturquoise
color | mistyrose
color | indigo

## ListsWiplimit

    {
      "value": 0,
      "enabled": true,
      "soft": true
    }

### Properties

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
value | number | true | none | value of the WIP
enabled | boolean | true | none | is the WIP enabled
soft | boolean | true | none | is the WIP a soft or hard requirement

## Swimlanes

    {
      "title": "string",
      "archived": true,
      "archivedAt": "string",
      "boardId": "string",
      "createdAt": "string",
      "sort": 0,
      "color": "white",
      "updatedAt": "string",
      "modifiedAt": "string",
      "type": "string",
      "collapsed": true
    }

A swimlane is an line in the kaban board.

### Properties

Name | Type | Required | Restrictions | Description
--- | --- | --- | --- | ---
title | string | true | none | the title of the swimlane
archived | boolean | true | none | is the swimlane archived?
archivedAt | string¦null | false | none | latest archiving date of the swimlane
boardId | string | true | none | the ID of the board the swimlane is attached to
createdAt | string | true | none | creation date of the swimlane
sort | number¦null | false | none | the sort value of the swimlane
color | string¦null | false | none | the color of the swimlane
updatedAt | string¦null | false | none | when was the swimlane last edited
modifiedAt | string | true | none | none
type | string | true | none | The type of swimlane
collapsed | boolean | true | none | is the swimlane collapsed

#### Enumerated Values

Property | Value
--- | ---
color | white
color | green
color | yellow
color | orange
color | red
color | purple
color | blue
color | sky
color | lime
color | pink
color | black
color | silver
color | peachpuff
color | crimson
color | plum
color | darkgreen
color | slateblue
color | magenta
color | gold
color | navy
color | gray
color | saddlebrown
color | paleturquoise
color | mistyrose
color | indigo

Shell HTTP JavaScript Node.js Ruby Python Java Go PHP