# Focalboard Server

## API and SDK Documentation

Version: 1.0.0

Focalboard Server

# Default

# addMember

Adds a new member to a board

    /boards/{boardID}/members

### Usage and SDK Samples

    curl -X POST \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "http://localhost/api/v2/boards/{boardID}/members" \
     -d '{
      "schemeAdmin" : true,
      "schemeCommenter" : true,
      "schemeViewer" : true,
      "roles" : "roles",
      "schemeEditor" : true,
      "boardId" : "boardId",
      "userId" : "userId"
    }'

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID
            BoardMember body = ; // BoardMember |

            try {
                BoardMember result = apiInstance.addMember(boardID, body);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#addMember");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID
            BoardMember body = ; // BoardMember |

            try {
                BoardMember result = apiInstance.addMember(boardID, body);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#addMember");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *boardID = boardID_example; // Board ID (default to null)
    BoardMember *body = ; //

    [apiInstance addMemberWith:boardID
        body:body
                  completionHandler: ^(BoardMember output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var boardID = boardID_example; // {String} Board ID
    var body = ; // {BoardMember}

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.addMember(boardID, body, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class addMemberExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var boardID = boardID_example;  // String | Board ID (default to null)
                var body = new BoardMember(); // BoardMember |

                try {
                    BoardMember result = apiInstance.addMember(boardID, body);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.addMember: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $boardID = boardID_example; // String | Board ID
    $body = ; // BoardMember |

    try {
        $result = $api_instance->addMember($boardID, $body);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->addMember: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $boardID = boardID_example; # String | Board ID
    my $body = WWW::OPenAPIClient::Object::BoardMember->new(); # BoardMember |

    eval {
        my $result = $api_instance->addMember(boardID => $boardID, body => $body);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->addMember: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    boardID = boardID_example # String | Board ID (default to null)
    body =  # BoardMember |

    try:
        api_response = api_instance.add_member(boardID, body)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->addMember: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let boardID = boardID_example; // String
        let body = ; // BoardMember

        let mut context = DefaultApi::Context::default();
        let result = client.addMember(boardID, body, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
boardID* | String Board ID Required

Body parameters

Name | Description
--- | ---
body * | membership to replace the current one with

## Responses

###

###

###

# archiveExportBoard

Exports an archive of all blocks for one boards.

    /boards/{boardID}/archive/export

### Usage and SDK Samples

    curl -X GET \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/boards/{boardID}/archive/export"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Id of board to export

            try {
                apiInstance.archiveExportBoard(boardID);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#archiveExportBoard");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Id of board to export

            try {
                apiInstance.archiveExportBoard(boardID);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#archiveExportBoard");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *boardID = boardID_example; // Id of board to export (default to null)

    // Exports an archive of all blocks for one boards.
    [apiInstance archiveExportBoardWith:boardID
                  completionHandler: ^(NSError* error) {
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var boardID = boardID_example; // {String} Id of board to export

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully.');
      }
    };
    api.archiveExportBoard(boardID, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class archiveExportBoardExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var boardID = boardID_example;  // String | Id of board to export (default to null)

                try {
                    // Exports an archive of all blocks for one boards.
                    apiInstance.archiveExportBoard(boardID);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.archiveExportBoard: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $boardID = boardID_example; // String | Id of board to export

    try {
        $api_instance->archiveExportBoard($boardID);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->archiveExportBoard: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $boardID = boardID_example; # String | Id of board to export

    eval {
        $api_instance->archiveExportBoard(boardID => $boardID);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->archiveExportBoard: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    boardID = boardID_example # String | Id of board to export (default to null)

    try:
        # Exports an archive of all blocks for one boards.
        api_instance.archive_export_board(boardID)
    except ApiException as e:
        print("Exception when calling DefaultApi->archiveExportBoard: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let boardID = boardID_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.archiveExportBoard(boardID, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
boardID* | String Id of board to export Required

## Responses

###

###

# archiveExportTeam

Exports an archive of all blocks for all the boards in a team.

    /teams/{teamID}/archive/export

### Usage and SDK Samples

    curl -X GET \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/teams/{teamID}/archive/export"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String teamID = teamID_example; // String | Id of team

            try {
                apiInstance.archiveExportTeam(teamID);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#archiveExportTeam");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String teamID = teamID_example; // String | Id of team

            try {
                apiInstance.archiveExportTeam(teamID);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#archiveExportTeam");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *teamID = teamID_example; // Id of team (default to null)

    // Exports an archive of all blocks for all the boards in a team.
    [apiInstance archiveExportTeamWith:teamID
                  completionHandler: ^(NSError* error) {
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var teamID = teamID_example; // {String} Id of team

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully.');
      }
    };
    api.archiveExportTeam(teamID, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class archiveExportTeamExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var teamID = teamID_example;  // String | Id of team (default to null)

                try {
                    // Exports an archive of all blocks for all the boards in a team.
                    apiInstance.archiveExportTeam(teamID);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.archiveExportTeam: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $teamID = teamID_example; // String | Id of team

    try {
        $api_instance->archiveExportTeam($teamID);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->archiveExportTeam: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $teamID = teamID_example; # String | Id of team

    eval {
        $api_instance->archiveExportTeam(teamID => $teamID);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->archiveExportTeam: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    teamID = teamID_example # String | Id of team (default to null)

    try:
        # Exports an archive of all blocks for all the boards in a team.
        api_instance.archive_export_team(teamID)
    except ApiException as e:
        print("Exception when calling DefaultApi->archiveExportTeam: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let teamID = teamID_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.archiveExportTeam(teamID, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
teamID* | String Id of team Required

## Responses

###

###

# archiveImport

Import an archive of boards.

    /teams/{teamID}/archive/import

### Usage and SDK Samples

    curl -X POST \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     -H "Content-Type: multipart/form-data" \
     "http://localhost/api/v2/teams/{teamID}/archive/import"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String teamID = teamID_example; // String | Team ID
            File file = BINARY_DATA_HERE; // File | archive file to import

            try {
                apiInstance.archiveImport(teamID, file);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#archiveImport");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String teamID = teamID_example; // String | Team ID
            File file = BINARY_DATA_HERE; // File | archive file to import

            try {
                apiInstance.archiveImport(teamID, file);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#archiveImport");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *teamID = teamID_example; // Team ID (default to null)
    File *file = BINARY_DATA_HERE; // archive file to import (default to null)

    // Import an archive of boards.
    [apiInstance archiveImportWith:teamID
        file:file
                  completionHandler: ^(NSError* error) {
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var teamID = teamID_example; // {String} Team ID
    var file = BINARY_DATA_HERE; // {File} archive file to import

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully.');
      }
    };
    api.archiveImport(teamID, file, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class archiveImportExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var teamID = teamID_example;  // String | Team ID (default to null)
                var file = BINARY_DATA_HERE;  // File | archive file to import (default to null)

                try {
                    // Import an archive of boards.
                    apiInstance.archiveImport(teamID, file);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.archiveImport: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $teamID = teamID_example; // String | Team ID
    $file = BINARY_DATA_HERE; // File | archive file to import

    try {
        $api_instance->archiveImport($teamID, $file);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->archiveImport: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $teamID = teamID_example; # String | Team ID
    my $file = BINARY_DATA_HERE; # File | archive file to import

    eval {
        $api_instance->archiveImport(teamID => $teamID, file => $file);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->archiveImport: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    teamID = teamID_example # String | Team ID (default to null)
    file = BINARY_DATA_HERE # File | archive file to import (default to null)

    try:
        # Import an archive of boards.
        api_instance.archive_import(teamID, file)
    except ApiException as e:
        print("Exception when calling DefaultApi->archiveImport: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let teamID = teamID_example; // String
        let file = BINARY_DATA_HERE; // File

        let mut context = DefaultApi::Context::default();
        let result = client.archiveImport(teamID, file, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
teamID* | String Team ID Required

Form parameters

Name | Description
--- | ---
file* | File (binary) archive file to import Required

## Responses

###

###

# changePassword

Change a user's password

    /users/{userID}/changepassword

### Usage and SDK Samples

    curl -X POST \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "http://localhost/api/v2/users/{userID}/changepassword" \
     -d '{
      "oldPassword" : "oldPassword",
      "newPassword" : "newPassword"
    }'

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String userID = userID_example; // String | User ID
            ChangePasswordRequest body = ; // ChangePasswordRequest |

            try {
                apiInstance.changePassword(userID, body);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#changePassword");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String userID = userID_example; // String | User ID
            ChangePasswordRequest body = ; // ChangePasswordRequest |

            try {
                apiInstance.changePassword(userID, body);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#changePassword");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *userID = userID_example; // User ID (default to null)
    ChangePasswordRequest *body = ; //

    [apiInstance changePasswordWith:userID
        body:body
                  completionHandler: ^(NSError* error) {
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var userID = userID_example; // {String} User ID
    var body = ; // {ChangePasswordRequest}

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully.');
      }
    };
    api.changePassword(userID, body, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class changePasswordExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var userID = userID_example;  // String | User ID (default to null)
                var body = new ChangePasswordRequest(); // ChangePasswordRequest |

                try {
                    apiInstance.changePassword(userID, body);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.changePassword: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $userID = userID_example; // String | User ID
    $body = ; // ChangePasswordRequest |

    try {
        $api_instance->changePassword($userID, $body);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->changePassword: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $userID = userID_example; # String | User ID
    my $body = WWW::OPenAPIClient::Object::ChangePasswordRequest->new(); # ChangePasswordRequest |

    eval {
        $api_instance->changePassword(userID => $userID, body => $body);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->changePassword: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    userID = userID_example # String | User ID (default to null)
    body =  # ChangePasswordRequest |

    try:
        api_instance.change_password(userID, body)
    except ApiException as e:
        print("Exception when calling DefaultApi->changePassword: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let userID = userID_example; // String
        let body = ; // ChangePasswordRequest

        let mut context = DefaultApi::Context::default();
        let result = client.changePassword(userID, body, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
userID* | String User ID Required

Body parameters

Name | Description
--- | ---
body * | Change password request

## Responses

###

###

###

# createBoard

Creates a new board

    /boards

### Usage and SDK Samples

    curl -X POST \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "http://localhost/api/v2/boards" \
     -d '{
      "deleteAt" : 6,
      "icon" : "icon",
      "description" : "description",
      "updateAt" : 5,
      "title" : "title",
      "type" : "type",
      "createAt" : 0,
      "showDescription" : true,
      "createdBy" : "createdBy",
      "isTemplate" : true,
      "teamId" : "teamId",
      "cardProperties" : [ {
        "key" : "{}"
      }, {
        "key" : "{}"
      } ],
      "modifiedBy" : "modifiedBy",
      "templateVersion" : 1,
      "id" : "id",
      "channelId" : "channelId",
      "properties" : {
        "key" : "{}"
      }
    }'

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            Board body = ; // Board |

            try {
                Board result = apiInstance.createBoard(body);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#createBoard");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            Board body = ; // Board |

            try {
                Board result = apiInstance.createBoard(body);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#createBoard");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    Board *body = ; //

    [apiInstance createBoardWith:body
                  completionHandler: ^(Board output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var body = ; // {Board}

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.createBoard(body, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class createBoardExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var body = new Board(); // Board |

                try {
                    Board result = apiInstance.createBoard(body);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.createBoard: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $body = ; // Board |

    try {
        $result = $api_instance->createBoard($body);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->createBoard: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $body = WWW::OPenAPIClient::Object::Board->new(); # Board |

    eval {
        my $result = $api_instance->createBoard(body => $body);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->createBoard: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    body =  # Board |

    try:
        api_response = api_instance.create_board(body)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->createBoard: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let body = ; // Board

        let mut context = DefaultApi::Context::default();
        let result = client.createBoard(body, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Body parameters

Name | Description
--- | ---
body * | the board to create

## Responses

###

###

# createCategory

Create a category for boards

    /teams/{teamID}/categories

### Usage and SDK Samples

    curl -X POST \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "http://localhost/api/v2/teams/{teamID}/categories" \
     -d '{
      "deleteAt" : 6,
      "teamID" : "teamID",
      "name" : "name",
      "updateAt" : 1,
      "id" : "id",
      "userID" : "userID",
      "createAt" : 0
    }'

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String teamID = teamID_example; // String | Team ID
            Category body = ; // Category |

            try {
                Category result = apiInstance.createCategory(teamID, body);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#createCategory");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String teamID = teamID_example; // String | Team ID
            Category body = ; // Category |

            try {
                Category result = apiInstance.createCategory(teamID, body);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#createCategory");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *teamID = teamID_example; // Team ID (default to null)
    Category *body = ; //

    [apiInstance createCategoryWith:teamID
        body:body
                  completionHandler: ^(Category output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var teamID = teamID_example; // {String} Team ID
    var body = ; // {Category}

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.createCategory(teamID, body, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class createCategoryExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var teamID = teamID_example;  // String | Team ID (default to null)
                var body = new Category(); // Category |

                try {
                    Category result = apiInstance.createCategory(teamID, body);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.createCategory: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $teamID = teamID_example; // String | Team ID
    $body = ; // Category |

    try {
        $result = $api_instance->createCategory($teamID, $body);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->createCategory: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $teamID = teamID_example; # String | Team ID
    my $body = WWW::OPenAPIClient::Object::Category->new(); # Category |

    eval {
        my $result = $api_instance->createCategory(teamID => $teamID, body => $body);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->createCategory: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    teamID = teamID_example # String | Team ID (default to null)
    body =  # Category |

    try:
        api_response = api_instance.create_category(teamID, body)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->createCategory: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let teamID = teamID_example; // String
        let body = ; // Category

        let mut context = DefaultApi::Context::default();
        let result = client.createCategory(teamID, body, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
teamID* | String Team ID Required

Body parameters

Name | Description
--- | ---
body * | category to create

## Responses

###

###

# createSubscription

Creates a subscription to a block for a user. The user will receive change notifications for the block.

    /subscriptions

### Usage and SDK Samples

    curl -X POST \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "http://localhost/api/v2/subscriptions" \
     -d '{
      "blockId" : "blockId",
      "deleteAt" : 6,
      "subscriberType" : "subscriberType",
      "blockType" : "blockType",
      "subscriberId" : "subscriberId",
      "notifiedAt" : 1,
      "createAt" : 0
    }'

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            Subscription body = ; // Subscription |

            try {
                User result = apiInstance.createSubscription(body);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#createSubscription");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            Subscription body = ; // Subscription |

            try {
                User result = apiInstance.createSubscription(body);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#createSubscription");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    Subscription *body = ; //

    // Creates a subscription to a block for a user. The user will receive change notifications for the block.
    [apiInstance createSubscriptionWith:body
                  completionHandler: ^(User output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var body = ; // {Subscription}

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.createSubscription(body, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class createSubscriptionExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var body = new Subscription(); // Subscription |

                try {
                    // Creates a subscription to a block for a user. The user will receive change notifications for the block.
                    User result = apiInstance.createSubscription(body);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.createSubscription: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $body = ; // Subscription |

    try {
        $result = $api_instance->createSubscription($body);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->createSubscription: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $body = WWW::OPenAPIClient::Object::Subscription->new(); # Subscription |

    eval {
        my $result = $api_instance->createSubscription(body => $body);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->createSubscription: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    body =  # Subscription |

    try:
        # Creates a subscription to a block for a user. The user will receive change notifications for the block.
        api_response = api_instance.create_subscription(body)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->createSubscription: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let body = ; // Subscription

        let mut context = DefaultApi::Context::default();
        let result = client.createSubscription(body, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Body parameters

Name | Description
--- | ---
body * | subscription definition

## Responses

###

###

# deleteBlock

Deletes a block

    /boards/{boardID}/blocks/{blockID}

### Usage and SDK Samples

    curl -X DELETE \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/boards/{boardID}/blocks/{blockID}"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID
            String blockID = blockID_example; // String | ID of block to delete

            try {
                apiInstance.deleteBlock(boardID, blockID);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#deleteBlock");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID
            String blockID = blockID_example; // String | ID of block to delete

            try {
                apiInstance.deleteBlock(boardID, blockID);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#deleteBlock");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *boardID = boardID_example; // Board ID (default to null)
    String *blockID = blockID_example; // ID of block to delete (default to null)

    [apiInstance deleteBlockWith:boardID
        blockID:blockID
                  completionHandler: ^(NSError* error) {
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var boardID = boardID_example; // {String} Board ID
    var blockID = blockID_example; // {String} ID of block to delete

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully.');
      }
    };
    api.deleteBlock(boardID, blockID, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class deleteBlockExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var boardID = boardID_example;  // String | Board ID (default to null)
                var blockID = blockID_example;  // String | ID of block to delete (default to null)

                try {
                    apiInstance.deleteBlock(boardID, blockID);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.deleteBlock: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $boardID = boardID_example; // String | Board ID
    $blockID = blockID_example; // String | ID of block to delete

    try {
        $api_instance->deleteBlock($boardID, $blockID);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->deleteBlock: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $boardID = boardID_example; # String | Board ID
    my $blockID = blockID_example; # String | ID of block to delete

    eval {
        $api_instance->deleteBlock(boardID => $boardID, blockID => $blockID);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->deleteBlock: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    boardID = boardID_example # String | Board ID (default to null)
    blockID = blockID_example # String | ID of block to delete (default to null)

    try:
        api_instance.delete_block(boardID, blockID)
    except ApiException as e:
        print("Exception when calling DefaultApi->deleteBlock: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let boardID = boardID_example; // String
        let blockID = blockID_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.deleteBlock(boardID, blockID, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
boardID* | String Board ID Required
blockID* | String ID of block to delete Required

## Responses

###

###

###

# deleteBoard

Removes a board

    /boards/{boardID}

### Usage and SDK Samples

    curl -X DELETE \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/boards/{boardID}"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID

            try {
                apiInstance.deleteBoard(boardID);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#deleteBoard");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID

            try {
                apiInstance.deleteBoard(boardID);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#deleteBoard");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *boardID = boardID_example; // Board ID (default to null)

    [apiInstance deleteBoardWith:boardID
                  completionHandler: ^(NSError* error) {
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var boardID = boardID_example; // {String} Board ID

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully.');
      }
    };
    api.deleteBoard(boardID, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class deleteBoardExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var boardID = boardID_example;  // String | Board ID (default to null)

                try {
                    apiInstance.deleteBoard(boardID);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.deleteBoard: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $boardID = boardID_example; // String | Board ID

    try {
        $api_instance->deleteBoard($boardID);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->deleteBoard: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $boardID = boardID_example; # String | Board ID

    eval {
        $api_instance->deleteBoard(boardID => $boardID);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->deleteBoard: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    boardID = boardID_example # String | Board ID (default to null)

    try:
        api_instance.delete_board(boardID)
    except ApiException as e:
        print("Exception when calling DefaultApi->deleteBoard: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let boardID = boardID_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.deleteBoard(boardID, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
boardID* | String Board ID Required

## Responses

###

###

###

# deleteBoardsAndBlocks

Deletes boards and blocks

    /boards-and-blocks

### Usage and SDK Samples

    curl -X DELETE \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "http://localhost/api/v2/boards-and-blocks" \
     -d '{
      "blocks" : [ "blocks", "blocks" ],
      "boards" : [ "boards", "boards" ]
    }'

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            DeleteBoardsAndBlocks body = ; // DeleteBoardsAndBlocks |

            try {
                apiInstance.deleteBoardsAndBlocks(body);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#deleteBoardsAndBlocks");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            DeleteBoardsAndBlocks body = ; // DeleteBoardsAndBlocks |

            try {
                apiInstance.deleteBoardsAndBlocks(body);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#deleteBoardsAndBlocks");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    DeleteBoardsAndBlocks *body = ; //

    [apiInstance deleteBoardsAndBlocksWith:body
                  completionHandler: ^(NSError* error) {
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var body = ; // {DeleteBoardsAndBlocks}

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully.');
      }
    };
    api.deleteBoardsAndBlocks(body, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class deleteBoardsAndBlocksExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var body = new DeleteBoardsAndBlocks(); // DeleteBoardsAndBlocks |

                try {
                    apiInstance.deleteBoardsAndBlocks(body);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.deleteBoardsAndBlocks: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $body = ; // DeleteBoardsAndBlocks |

    try {
        $api_instance->deleteBoardsAndBlocks($body);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->deleteBoardsAndBlocks: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $body = WWW::OPenAPIClient::Object::DeleteBoardsAndBlocks->new(); # DeleteBoardsAndBlocks |

    eval {
        $api_instance->deleteBoardsAndBlocks(body => $body);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->deleteBoardsAndBlocks: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    body =  # DeleteBoardsAndBlocks |

    try:
        api_instance.delete_boards_and_blocks(body)
    except ApiException as e:
        print("Exception when calling DefaultApi->deleteBoardsAndBlocks: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let body = ; // DeleteBoardsAndBlocks

        let mut context = DefaultApi::Context::default();
        let result = client.deleteBoardsAndBlocks(body, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Body parameters

Name | Description
--- | ---
body * | the boards and blocks to delete

## Responses

###

###

# deleteCategory

Delete a category

    /teams/{teamID}/categories/{categoryID}

### Usage and SDK Samples

    curl -X DELETE \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/teams/{teamID}/categories/{categoryID}"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String teamID = teamID_example; // String | Team ID
            String categoryID = categoryID_example; // String | Category ID

            try {
                apiInstance.deleteCategory(teamID, categoryID);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#deleteCategory");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String teamID = teamID_example; // String | Team ID
            String categoryID = categoryID_example; // String | Category ID

            try {
                apiInstance.deleteCategory(teamID, categoryID);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#deleteCategory");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *teamID = teamID_example; // Team ID (default to null)
    String *categoryID = categoryID_example; // Category ID (default to null)

    [apiInstance deleteCategoryWith:teamID
        categoryID:categoryID
                  completionHandler: ^(NSError* error) {
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var teamID = teamID_example; // {String} Team ID
    var categoryID = categoryID_example; // {String} Category ID

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully.');
      }
    };
    api.deleteCategory(teamID, categoryID, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class deleteCategoryExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var teamID = teamID_example;  // String | Team ID (default to null)
                var categoryID = categoryID_example;  // String | Category ID (default to null)

                try {
                    apiInstance.deleteCategory(teamID, categoryID);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.deleteCategory: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $teamID = teamID_example; // String | Team ID
    $categoryID = categoryID_example; // String | Category ID

    try {
        $api_instance->deleteCategory($teamID, $categoryID);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->deleteCategory: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $teamID = teamID_example; # String | Team ID
    my $categoryID = categoryID_example; # String | Category ID

    eval {
        $api_instance->deleteCategory(teamID => $teamID, categoryID => $categoryID);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->deleteCategory: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    teamID = teamID_example # String | Team ID (default to null)
    categoryID = categoryID_example # String | Category ID (default to null)

    try:
        api_instance.delete_category(teamID, categoryID)
    except ApiException as e:
        print("Exception when calling DefaultApi->deleteCategory: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let teamID = teamID_example; // String
        let categoryID = categoryID_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.deleteCategory(teamID, categoryID, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
teamID* | String Team ID Required
categoryID* | String Category ID Required

## Responses

###

###

# deleteMember

Deletes a member from a board

    /boards/{boardID}/members/{userID}

### Usage and SDK Samples

    curl -X DELETE \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/boards/{boardID}/members/{userID}"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID
            String userID = userID_example; // String | User ID

            try {
                apiInstance.deleteMember(boardID, userID);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#deleteMember");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID
            String userID = userID_example; // String | User ID

            try {
                apiInstance.deleteMember(boardID, userID);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#deleteMember");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *boardID = boardID_example; // Board ID (default to null)
    String *userID = userID_example; // User ID (default to null)

    [apiInstance deleteMemberWith:boardID
        userID:userID
                  completionHandler: ^(NSError* error) {
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var boardID = boardID_example; // {String} Board ID
    var userID = userID_example; // {String} User ID

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully.');
      }
    };
    api.deleteMember(boardID, userID, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class deleteMemberExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var boardID = boardID_example;  // String | Board ID (default to null)
                var userID = userID_example;  // String | User ID (default to null)

                try {
                    apiInstance.deleteMember(boardID, userID);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.deleteMember: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $boardID = boardID_example; // String | Board ID
    $userID = userID_example; // String | User ID

    try {
        $api_instance->deleteMember($boardID, $userID);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->deleteMember: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $boardID = boardID_example; # String | Board ID
    my $userID = userID_example; # String | User ID

    eval {
        $api_instance->deleteMember(boardID => $boardID, userID => $userID);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->deleteMember: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    boardID = boardID_example # String | Board ID (default to null)
    userID = userID_example # String | User ID (default to null)

    try:
        api_instance.delete_member(boardID, userID)
    except ApiException as e:
        print("Exception when calling DefaultApi->deleteMember: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let boardID = boardID_example; // String
        let userID = userID_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.deleteMember(boardID, userID, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
boardID* | String Board ID Required
userID* | String User ID Required

## Responses

###

###

###

# deleteSubscription

Deletes a subscription a user has for a a block. The user will no longer receive change notifications for the block.

    /subscriptions/{blockID}/{subscriberID}

### Usage and SDK Samples

    curl -X DELETE \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/subscriptions/{blockID}/{subscriberID}"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String blockID = blockID_example; // String | Block ID
            String subscriberID = subscriberID_example; // String | Subscriber ID

            try {
                apiInstance.deleteSubscription(blockID, subscriberID);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#deleteSubscription");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String blockID = blockID_example; // String | Block ID
            String subscriberID = subscriberID_example; // String | Subscriber ID

            try {
                apiInstance.deleteSubscription(blockID, subscriberID);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#deleteSubscription");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *blockID = blockID_example; // Block ID (default to null)
    String *subscriberID = subscriberID_example; // Subscriber ID (default to null)

    // Deletes a subscription a user has for a a block. The user will no longer receive change notifications for the block.
    [apiInstance deleteSubscriptionWith:blockID
        subscriberID:subscriberID
                  completionHandler: ^(NSError* error) {
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var blockID = blockID_example; // {String} Block ID
    var subscriberID = subscriberID_example; // {String} Subscriber ID

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully.');
      }
    };
    api.deleteSubscription(blockID, subscriberID, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class deleteSubscriptionExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var blockID = blockID_example;  // String | Block ID (default to null)
                var subscriberID = subscriberID_example;  // String | Subscriber ID (default to null)

                try {
                    // Deletes a subscription a user has for a a block. The user will no longer receive change notifications for the block.
                    apiInstance.deleteSubscription(blockID, subscriberID);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.deleteSubscription: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $blockID = blockID_example; // String | Block ID
    $subscriberID = subscriberID_example; // String | Subscriber ID

    try {
        $api_instance->deleteSubscription($blockID, $subscriberID);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->deleteSubscription: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $blockID = blockID_example; # String | Block ID
    my $subscriberID = subscriberID_example; # String | Subscriber ID

    eval {
        $api_instance->deleteSubscription(blockID => $blockID, subscriberID => $subscriberID);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->deleteSubscription: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    blockID = blockID_example # String | Block ID (default to null)
    subscriberID = subscriberID_example # String | Subscriber ID (default to null)

    try:
        # Deletes a subscription a user has for a a block. The user will no longer receive change notifications for the block.
        api_instance.delete_subscription(blockID, subscriberID)
    except ApiException as e:
        print("Exception when calling DefaultApi->deleteSubscription: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let blockID = blockID_example; // String
        let subscriberID = subscriberID_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.deleteSubscription(blockID, subscriberID, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
blockID* | String Block ID Required
subscriberID* | String Subscriber ID Required

## Responses

###

###

# duplicateBlock

Returns the new created blocks

    /boards/{boardID}/blocks/{blockID}/duplicate

### Usage and SDK Samples

    curl -X POST \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/boards/{boardID}/blocks/{blockID}/duplicate"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID
            String blockID = blockID_example; // String | Block ID

            try {
                array[Block] result = apiInstance.duplicateBlock(boardID, blockID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#duplicateBlock");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID
            String blockID = blockID_example; // String | Block ID

            try {
                array[Block] result = apiInstance.duplicateBlock(boardID, blockID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#duplicateBlock");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *boardID = boardID_example; // Board ID (default to null)
    String *blockID = blockID_example; // Block ID (default to null)

    [apiInstance duplicateBlockWith:boardID
        blockID:blockID
                  completionHandler: ^(array[Block] output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var boardID = boardID_example; // {String} Board ID
    var blockID = blockID_example; // {String} Block ID

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.duplicateBlock(boardID, blockID, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class duplicateBlockExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var boardID = boardID_example;  // String | Board ID (default to null)
                var blockID = blockID_example;  // String | Block ID (default to null)

                try {
                    array[Block] result = apiInstance.duplicateBlock(boardID, blockID);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.duplicateBlock: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $boardID = boardID_example; // String | Board ID
    $blockID = blockID_example; // String | Block ID

    try {
        $result = $api_instance->duplicateBlock($boardID, $blockID);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->duplicateBlock: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $boardID = boardID_example; # String | Board ID
    my $blockID = blockID_example; # String | Block ID

    eval {
        my $result = $api_instance->duplicateBlock(boardID => $boardID, blockID => $blockID);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->duplicateBlock: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    boardID = boardID_example # String | Board ID (default to null)
    blockID = blockID_example # String | Block ID (default to null)

    try:
        api_response = api_instance.duplicate_block(boardID, blockID)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->duplicateBlock: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let boardID = boardID_example; // String
        let blockID = blockID_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.duplicateBlock(boardID, blockID, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
boardID* | String Board ID Required
blockID* | String Block ID Required

## Responses

###

###

###

# duplicateBoard

Returns the new created board and all the blocks

    /boards/{boardID}/duplicate

### Usage and SDK Samples

    curl -X POST \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/boards/{boardID}/duplicate"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID

            try {
                BoardsAndBlocks result = apiInstance.duplicateBoard(boardID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#duplicateBoard");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID

            try {
                BoardsAndBlocks result = apiInstance.duplicateBoard(boardID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#duplicateBoard");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *boardID = boardID_example; // Board ID (default to null)

    [apiInstance duplicateBoardWith:boardID
                  completionHandler: ^(BoardsAndBlocks output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var boardID = boardID_example; // {String} Board ID

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.duplicateBoard(boardID, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class duplicateBoardExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var boardID = boardID_example;  // String | Board ID (default to null)

                try {
                    BoardsAndBlocks result = apiInstance.duplicateBoard(boardID);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.duplicateBoard: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $boardID = boardID_example; // String | Board ID

    try {
        $result = $api_instance->duplicateBoard($boardID);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->duplicateBoard: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $boardID = boardID_example; # String | Board ID

    eval {
        my $result = $api_instance->duplicateBoard(boardID => $boardID);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->duplicateBoard: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    boardID = boardID_example # String | Board ID (default to null)

    try:
        api_response = api_instance.duplicate_board(boardID)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->duplicateBoard: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let boardID = boardID_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.duplicateBoard(boardID, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
boardID* | String Board ID Required

## Responses

###

###

###

# getBlocks

Returns blocks

    /boards/{boardID}/blocks

### Usage and SDK Samples

    curl -X GET \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/boards/{boardID}/blocks?parent_id=parentId_example&type=type_example"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID
            String parentId = parentId_example; // String | ID of parent block, omit to specify all blocks
            String type = type_example; // String | Type of blocks to return, omit to specify all types

            try {
                array[Block] result = apiInstance.getBlocks(boardID, parentId, type);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getBlocks");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID
            String parentId = parentId_example; // String | ID of parent block, omit to specify all blocks
            String type = type_example; // String | Type of blocks to return, omit to specify all types

            try {
                array[Block] result = apiInstance.getBlocks(boardID, parentId, type);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getBlocks");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *boardID = boardID_example; // Board ID (default to null)
    String *parentId = parentId_example; // ID of parent block, omit to specify all blocks (optional) (default to null)
    String *type = type_example; // Type of blocks to return, omit to specify all types (optional) (default to null)

    [apiInstance getBlocksWith:boardID
        parentId:parentId
        type:type
                  completionHandler: ^(array[Block] output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var boardID = boardID_example; // {String} Board ID
    var opts = {
      'parentId': parentId_example, // {String} ID of parent block, omit to specify all blocks
      'type': type_example // {String} Type of blocks to return, omit to specify all types
    };

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.getBlocks(boardID, opts, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class getBlocksExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var boardID = boardID_example;  // String | Board ID (default to null)
                var parentId = parentId_example;  // String | ID of parent block, omit to specify all blocks (optional)  (default to null)
                var type = type_example;  // String | Type of blocks to return, omit to specify all types (optional)  (default to null)

                try {
                    array[Block] result = apiInstance.getBlocks(boardID, parentId, type);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getBlocks: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $boardID = boardID_example; // String | Board ID
    $parentId = parentId_example; // String | ID of parent block, omit to specify all blocks
    $type = type_example; // String | Type of blocks to return, omit to specify all types

    try {
        $result = $api_instance->getBlocks($boardID, $parentId, $type);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getBlocks: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $boardID = boardID_example; # String | Board ID
    my $parentId = parentId_example; # String | ID of parent block, omit to specify all blocks
    my $type = type_example; # String | Type of blocks to return, omit to specify all types

    eval {
        my $result = $api_instance->getBlocks(boardID => $boardID, parentId => $parentId, type => $type);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getBlocks: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    boardID = boardID_example # String | Board ID (default to null)
    parentId = parentId_example # String | ID of parent block, omit to specify all blocks (optional) (default to null)
    type = type_example # String | Type of blocks to return, omit to specify all types (optional) (default to null)

    try:
        api_response = api_instance.get_blocks(boardID, parentId=parentId, type=type)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getBlocks: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let boardID = boardID_example; // String
        let parentId = parentId_example; // String
        let type = type_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.getBlocks(boardID, parentId, type, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
boardID* | String Board ID Required

Query parameters

Name | Description
--- | ---
parent_id | String ID of parent block, omit to specify all blocks
type | String Type of blocks to return, omit to specify all types

## Responses

###

###

###

# getBoard

Returns a board

    /boards/{boardID}

### Usage and SDK Samples

    curl -X GET \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/boards/{boardID}"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID

            try {
                Board result = apiInstance.getBoard(boardID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getBoard");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID

            try {
                Board result = apiInstance.getBoard(boardID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getBoard");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *boardID = boardID_example; // Board ID (default to null)

    [apiInstance getBoardWith:boardID
                  completionHandler: ^(Board output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var boardID = boardID_example; // {String} Board ID

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.getBoard(boardID, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class getBoardExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var boardID = boardID_example;  // String | Board ID (default to null)

                try {
                    Board result = apiInstance.getBoard(boardID);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getBoard: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $boardID = boardID_example; // String | Board ID

    try {
        $result = $api_instance->getBoard($boardID);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getBoard: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $boardID = boardID_example; # String | Board ID

    eval {
        my $result = $api_instance->getBoard(boardID => $boardID);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getBoard: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    boardID = boardID_example # String | Board ID (default to null)

    try:
        api_response = api_instance.get_board(boardID)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getBoard: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let boardID = boardID_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.getBoard(boardID, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
boardID* | String Board ID Required

## Responses

###

###

###

# getBoardMetadata

Returns a board's metadata

    /boards/{boardID}/metadata

### Usage and SDK Samples

    curl -X GET \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/boards/{boardID}/metadata"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID

            try {
                BoardMetadata result = apiInstance.getBoardMetadata(boardID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getBoardMetadata");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID

            try {
                BoardMetadata result = apiInstance.getBoardMetadata(boardID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getBoardMetadata");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *boardID = boardID_example; // Board ID (default to null)

    [apiInstance getBoardMetadataWith:boardID
                  completionHandler: ^(BoardMetadata output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var boardID = boardID_example; // {String} Board ID

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.getBoardMetadata(boardID, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class getBoardMetadataExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var boardID = boardID_example;  // String | Board ID (default to null)

                try {
                    BoardMetadata result = apiInstance.getBoardMetadata(boardID);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getBoardMetadata: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $boardID = boardID_example; // String | Board ID

    try {
        $result = $api_instance->getBoardMetadata($boardID);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getBoardMetadata: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $boardID = boardID_example; # String | Board ID

    eval {
        my $result = $api_instance->getBoardMetadata(boardID => $boardID);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getBoardMetadata: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    boardID = boardID_example # String | Board ID (default to null)

    try:
        api_response = api_instance.get_board_metadata(boardID)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getBoardMetadata: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let boardID = boardID_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.getBoardMetadata(boardID, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
boardID* | String Board ID Required

## Responses

###

###

###

###

# getBoards

Returns team boards

    /teams/{teamID}/boards

### Usage and SDK Samples

    curl -X GET \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/teams/{teamID}/boards"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String teamID = teamID_example; // String | Team ID

            try {
                array[Board] result = apiInstance.getBoards(teamID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getBoards");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String teamID = teamID_example; // String | Team ID

            try {
                array[Board] result = apiInstance.getBoards(teamID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getBoards");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *teamID = teamID_example; // Team ID (default to null)

    [apiInstance getBoardsWith:teamID
                  completionHandler: ^(array[Board] output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var teamID = teamID_example; // {String} Team ID

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.getBoards(teamID, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class getBoardsExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var teamID = teamID_example;  // String | Team ID (default to null)

                try {
                    array[Board] result = apiInstance.getBoards(teamID);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getBoards: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $teamID = teamID_example; // String | Team ID

    try {
        $result = $api_instance->getBoards($teamID);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getBoards: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $teamID = teamID_example; # String | Team ID

    eval {
        my $result = $api_instance->getBoards(teamID => $teamID);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getBoards: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    teamID = teamID_example # String | Team ID (default to null)

    try:
        api_response = api_instance.get_boards(teamID)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getBoards: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let teamID = teamID_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.getBoards(teamID, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
teamID* | String Team ID Required

## Responses

###

###

# getClientConfig

Returns the client configuration

    /clientConfig

### Usage and SDK Samples

    curl -X GET \
     -H "Accept: application/json" \
     "http://localhost/api/v2/clientConfig"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();

            try {
                ClientConfig result = apiInstance.getClientConfig();
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getClientConfig");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();

            try {
                ClientConfig result = apiInstance.getClientConfig();
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getClientConfig");
                e.printStackTrace();
            }
        }
    }

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];

    [apiInstance getClientConfigWithCompletionHandler:
                  ^(ClientConfig output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.getClientConfig(callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class getClientConfigExample
        {
            public void main()
            {

                // Create an instance of the API class
                var apiInstance = new DefaultApi();

                try {
                    ClientConfig result = apiInstance.getClientConfig();
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getClientConfig: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();

    try {
        $result = $api_instance->getClientConfig();
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getClientConfig: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

    eval {
        my $result = $api_instance->getClientConfig();
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getClientConfig: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()

    try:
        api_response = api_instance.get_client_config()
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getClientConfig: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {

        let mut context = DefaultApi::Context::default();
        let result = client.getClientConfig(&context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

## Responses

###

###

# getMe

Returns the currently logged-in user

    /users/me

### Usage and SDK Samples

    curl -X GET \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/users/me"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();

            try {
                User result = apiInstance.getMe();
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getMe");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();

            try {
                User result = apiInstance.getMe();
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getMe");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];

    [apiInstance getMeWithCompletionHandler:
                  ^(User output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.getMe(callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class getMeExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();

                try {
                    User result = apiInstance.getMe();
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getMe: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();

    try {
        $result = $api_instance->getMe();
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getMe: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

    eval {
        my $result = $api_instance->getMe();
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getMe: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()

    try:
        api_response = api_instance.get_me()
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getMe: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {

        let mut context = DefaultApi::Context::default();
        let result = client.getMe(&context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

## Responses

###

###

# getMembersForBoard

Returns the members of the board

    /boards/{boardID}/members

### Usage and SDK Samples

    curl -X GET \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/boards/{boardID}/members"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID

            try {
                array[BoardMember] result = apiInstance.getMembersForBoard(boardID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getMembersForBoard");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID

            try {
                array[BoardMember] result = apiInstance.getMembersForBoard(boardID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getMembersForBoard");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *boardID = boardID_example; // Board ID (default to null)

    [apiInstance getMembersForBoardWith:boardID
                  completionHandler: ^(array[BoardMember] output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var boardID = boardID_example; // {String} Board ID

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.getMembersForBoard(boardID, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class getMembersForBoardExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var boardID = boardID_example;  // String | Board ID (default to null)

                try {
                    array[BoardMember] result = apiInstance.getMembersForBoard(boardID);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getMembersForBoard: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $boardID = boardID_example; // String | Board ID

    try {
        $result = $api_instance->getMembersForBoard($boardID);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getMembersForBoard: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $boardID = boardID_example; # String | Board ID

    eval {
        my $result = $api_instance->getMembersForBoard(boardID => $boardID);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getMembersForBoard: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    boardID = boardID_example # String | Board ID (default to null)

    try:
        api_response = api_instance.get_members_for_board(boardID)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getMembersForBoard: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let boardID = boardID_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.getMembersForBoard(boardID, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
boardID* | String Board ID Required

## Responses

###

###

# getMyMemberships

Returns the currently users board memberships

    /users/me/memberships

### Usage and SDK Samples

    curl -X GET \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/users/me/memberships"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();

            try {
                array[BoardMember] result = apiInstance.getMyMemberships();
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getMyMemberships");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();

            try {
                array[BoardMember] result = apiInstance.getMyMemberships();
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getMyMemberships");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];

    [apiInstance getMyMembershipsWithCompletionHandler:
                  ^(array[BoardMember] output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.getMyMemberships(callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class getMyMembershipsExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();

                try {
                    array[BoardMember] result = apiInstance.getMyMemberships();
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getMyMemberships: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();

    try {
        $result = $api_instance->getMyMemberships();
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getMyMemberships: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

    eval {
        my $result = $api_instance->getMyMemberships();
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getMyMemberships: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()

    try:
        api_response = api_instance.get_my_memberships()
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getMyMemberships: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {

        let mut context = DefaultApi::Context::default();
        let result = client.getMyMemberships(&context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

## Responses

###

###

# getSharing

Returns sharing information for a board

    /boards/{boardID}/sharing

### Usage and SDK Samples

    curl -X GET \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/boards/{boardID}/sharing"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID

            try {
                Sharing result = apiInstance.getSharing(boardID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getSharing");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID

            try {
                Sharing result = apiInstance.getSharing(boardID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getSharing");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *boardID = boardID_example; // Board ID (default to null)

    [apiInstance getSharingWith:boardID
                  completionHandler: ^(Sharing output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var boardID = boardID_example; // {String} Board ID

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.getSharing(boardID, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class getSharingExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var boardID = boardID_example;  // String | Board ID (default to null)

                try {
                    Sharing result = apiInstance.getSharing(boardID);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getSharing: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $boardID = boardID_example; // String | Board ID

    try {
        $result = $api_instance->getSharing($boardID);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getSharing: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $boardID = boardID_example; # String | Board ID

    eval {
        my $result = $api_instance->getSharing(boardID => $boardID);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getSharing: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    boardID = boardID_example # String | Board ID (default to null)

    try:
        api_response = api_instance.get_sharing(boardID)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getSharing: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let boardID = boardID_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.getSharing(boardID, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
boardID* | String Board ID Required

## Responses

###

###

###

# getSubscriptions

Gets subscriptions for a user.

    /subscriptions/{subscriberID}

### Usage and SDK Samples

    curl -X GET \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/subscriptions/{subscriberID}"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String subscriberID = subscriberID_example; // String | Subscriber ID

            try {
                array[User] result = apiInstance.getSubscriptions(subscriberID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getSubscriptions");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String subscriberID = subscriberID_example; // String | Subscriber ID

            try {
                array[User] result = apiInstance.getSubscriptions(subscriberID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getSubscriptions");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *subscriberID = subscriberID_example; // Subscriber ID (default to null)

    // Gets subscriptions for a user.
    [apiInstance getSubscriptionsWith:subscriberID
                  completionHandler: ^(array[User] output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var subscriberID = subscriberID_example; // {String} Subscriber ID

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.getSubscriptions(subscriberID, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class getSubscriptionsExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var subscriberID = subscriberID_example;  // String | Subscriber ID (default to null)

                try {
                    // Gets subscriptions for a user.
                    array[User] result = apiInstance.getSubscriptions(subscriberID);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getSubscriptions: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $subscriberID = subscriberID_example; // String | Subscriber ID

    try {
        $result = $api_instance->getSubscriptions($subscriberID);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getSubscriptions: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $subscriberID = subscriberID_example; # String | Subscriber ID

    eval {
        my $result = $api_instance->getSubscriptions(subscriberID => $subscriberID);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getSubscriptions: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    subscriberID = subscriberID_example # String | Subscriber ID (default to null)

    try:
        # Gets subscriptions for a user.
        api_response = api_instance.get_subscriptions(subscriberID)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getSubscriptions: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let subscriberID = subscriberID_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.getSubscriptions(subscriberID, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
subscriberID* | String Subscriber ID Required

## Responses

###

###

# getTeam

Returns information of the root team

    /teams/{teamID}

### Usage and SDK Samples

    curl -X GET \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/teams/{teamID}"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String teamID = teamID_example; // String | Team ID

            try {
                Team result = apiInstance.getTeam(teamID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getTeam");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String teamID = teamID_example; // String | Team ID

            try {
                Team result = apiInstance.getTeam(teamID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getTeam");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *teamID = teamID_example; // Team ID (default to null)

    [apiInstance getTeamWith:teamID
                  completionHandler: ^(Team output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var teamID = teamID_example; // {String} Team ID

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.getTeam(teamID, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class getTeamExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var teamID = teamID_example;  // String | Team ID (default to null)

                try {
                    Team result = apiInstance.getTeam(teamID);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getTeam: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $teamID = teamID_example; // String | Team ID

    try {
        $result = $api_instance->getTeam($teamID);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getTeam: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $teamID = teamID_example; # String | Team ID

    eval {
        my $result = $api_instance->getTeam(teamID => $teamID);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getTeam: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    teamID = teamID_example # String | Team ID (default to null)

    try:
        api_response = api_instance.get_team(teamID)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getTeam: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let teamID = teamID_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.getTeam(teamID, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
teamID* | String Team ID Required

## Responses

###

###

# getTeamUsers

Returns team users

    /teams/{teamID}/users

### Usage and SDK Samples

    curl -X GET \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/teams/{teamID}/users?search=search_example"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String teamID = teamID_example; // String | Team ID
            String search = search_example; // String | string to filter users list

            try {
                array[User] result = apiInstance.getTeamUsers(teamID, search);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getTeamUsers");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String teamID = teamID_example; // String | Team ID
            String search = search_example; // String | string to filter users list

            try {
                array[User] result = apiInstance.getTeamUsers(teamID, search);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getTeamUsers");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *teamID = teamID_example; // Team ID (default to null)
    String *search = search_example; // string to filter users list (optional) (default to null)

    [apiInstance getTeamUsersWith:teamID
        search:search
                  completionHandler: ^(array[User] output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var teamID = teamID_example; // {String} Team ID
    var opts = {
      'search': search_example // {String} string to filter users list
    };

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.getTeamUsers(teamID, opts, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class getTeamUsersExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var teamID = teamID_example;  // String | Team ID (default to null)
                var search = search_example;  // String | string to filter users list (optional)  (default to null)

                try {
                    array[User] result = apiInstance.getTeamUsers(teamID, search);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getTeamUsers: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $teamID = teamID_example; // String | Team ID
    $search = search_example; // String | string to filter users list

    try {
        $result = $api_instance->getTeamUsers($teamID, $search);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getTeamUsers: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $teamID = teamID_example; # String | Team ID
    my $search = search_example; # String | string to filter users list

    eval {
        my $result = $api_instance->getTeamUsers(teamID => $teamID, search => $search);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getTeamUsers: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    teamID = teamID_example # String | Team ID (default to null)
    search = search_example # String | string to filter users list (optional) (default to null)

    try:
        api_response = api_instance.get_team_users(teamID, search=search)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getTeamUsers: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let teamID = teamID_example; // String
        let search = search_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.getTeamUsers(teamID, search, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
teamID* | String Team ID Required

Query parameters

Name | Description
--- | ---
search | String string to filter users list

## Responses

###

###

# getTeams

Returns information of all the teams

    /teams

### Usage and SDK Samples

    curl -X GET \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/teams"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();

            try {
                array[Team] result = apiInstance.getTeams();
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getTeams");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();

            try {
                array[Team] result = apiInstance.getTeams();
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getTeams");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];

    [apiInstance getTeamsWithCompletionHandler:
                  ^(array[Team] output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.getTeams(callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class getTeamsExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();

                try {
                    array[Team] result = apiInstance.getTeams();
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getTeams: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();

    try {
        $result = $api_instance->getTeams();
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getTeams: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

    eval {
        my $result = $api_instance->getTeams();
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getTeams: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()

    try:
        api_response = api_instance.get_teams()
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getTeams: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {

        let mut context = DefaultApi::Context::default();
        let result = client.getTeams(&context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

## Responses

###

###

# getTemplates

Returns team templates

    /teams/{teamID}/templates

### Usage and SDK Samples

    curl -X GET \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/teams/{teamID}/templates"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String teamID = teamID_example; // String | Team ID

            try {
                array[Board] result = apiInstance.getTemplates(teamID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getTemplates");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String teamID = teamID_example; // String | Team ID

            try {
                array[Board] result = apiInstance.getTemplates(teamID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getTemplates");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *teamID = teamID_example; // Team ID (default to null)

    [apiInstance getTemplatesWith:teamID
                  completionHandler: ^(array[Board] output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var teamID = teamID_example; // {String} Team ID

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.getTemplates(teamID, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class getTemplatesExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var teamID = teamID_example;  // String | Team ID (default to null)

                try {
                    array[Board] result = apiInstance.getTemplates(teamID);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getTemplates: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $teamID = teamID_example; // String | Team ID

    try {
        $result = $api_instance->getTemplates($teamID);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getTemplates: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $teamID = teamID_example; # String | Team ID

    eval {
        my $result = $api_instance->getTemplates(teamID => $teamID);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getTemplates: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    teamID = teamID_example # String | Team ID (default to null)

    try:
        api_response = api_instance.get_templates(teamID)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getTemplates: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let teamID = teamID_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.getTemplates(teamID, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
teamID* | String Team ID Required

## Responses

###

###

# getUser

Returns a user

    /users/{userID}

### Usage and SDK Samples

    curl -X GET \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/users/{userID}"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String userID = userID_example; // String | User ID

            try {
                User result = apiInstance.getUser(userID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getUser");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String userID = userID_example; // String | User ID

            try {
                User result = apiInstance.getUser(userID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getUser");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *userID = userID_example; // User ID (default to null)

    [apiInstance getUserWith:userID
                  completionHandler: ^(User output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var userID = userID_example; // {String} User ID

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.getUser(userID, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class getUserExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var userID = userID_example;  // String | User ID (default to null)

                try {
                    User result = apiInstance.getUser(userID);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getUser: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $userID = userID_example; // String | User ID

    try {
        $result = $api_instance->getUser($userID);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getUser: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $userID = userID_example; # String | User ID

    eval {
        my $result = $api_instance->getUser(userID => $userID);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getUser: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    userID = userID_example # String | User ID (default to null)

    try:
        api_response = api_instance.get_user(userID)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getUser: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let userID = userID_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.getUser(userID, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
userID* | String User ID Required

## Responses

###

###

# getUserCategoryBoards

Gets the user's board categories

    /teams/{teamID}/categories

### Usage and SDK Samples

    curl -X GET \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/teams/{teamID}/categories"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String teamID = teamID_example; // String | Team ID

            try {
                array[CategoryBoards] result = apiInstance.getUserCategoryBoards(teamID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getUserCategoryBoards");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String teamID = teamID_example; // String | Team ID

            try {
                array[CategoryBoards] result = apiInstance.getUserCategoryBoards(teamID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getUserCategoryBoards");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *teamID = teamID_example; // Team ID (default to null)

    [apiInstance getUserCategoryBoardsWith:teamID
                  completionHandler: ^(array[CategoryBoards] output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var teamID = teamID_example; // {String} Team ID

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.getUserCategoryBoards(teamID, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class getUserCategoryBoardsExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var teamID = teamID_example;  // String | Team ID (default to null)

                try {
                    array[CategoryBoards] result = apiInstance.getUserCategoryBoards(teamID);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getUserCategoryBoards: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $teamID = teamID_example; // String | Team ID

    try {
        $result = $api_instance->getUserCategoryBoards($teamID);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getUserCategoryBoards: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $teamID = teamID_example; # String | Team ID

    eval {
        my $result = $api_instance->getUserCategoryBoards(teamID => $teamID);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getUserCategoryBoards: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    teamID = teamID_example # String | Team ID (default to null)

    try:
        api_response = api_instance.get_user_category_boards(teamID)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getUserCategoryBoards: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let teamID = teamID_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.getUserCategoryBoards(teamID, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
teamID* | String Team ID Required

## Responses

###

###

# insertBoardsAndBlocks

Creates new boards and blocks

    /boards-and-blocks

### Usage and SDK Samples

    curl -X POST \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "http://localhost/api/v2/boards-and-blocks" \
     -d '{
      "blocks" : [ {
        "schema" : 1,
        "createdBy" : "createdBy",
        "deleteAt" : 6,
        "boardId" : "boardId",
        "updateAt" : 5,
        "modifiedBy" : "modifiedBy",
        "id" : "id",
        "fields" : {
          "key" : "{}"
        },
        "title" : "title",
        "type" : "type",
        "createAt" : 0,
        "parentId" : "parentId"
      }, {
        "schema" : 1,
        "createdBy" : "createdBy",
        "deleteAt" : 6,
        "boardId" : "boardId",
        "updateAt" : 5,
        "modifiedBy" : "modifiedBy",
        "id" : "id",
        "fields" : {
          "key" : "{}"
        },
        "title" : "title",
        "type" : "type",
        "createAt" : 0,
        "parentId" : "parentId"
      } ],
      "boards" : [ {
        "deleteAt" : 6,
        "icon" : "icon",
        "description" : "description",
        "updateAt" : 5,
        "title" : "title",
        "type" : "type",
        "createAt" : 0,
        "showDescription" : true,
        "createdBy" : "createdBy",
        "isTemplate" : true,
        "teamId" : "teamId",
        "cardProperties" : [ {
          "key" : "{}"
        }, {
          "key" : "{}"
        } ],
        "modifiedBy" : "modifiedBy",
        "templateVersion" : 1,
        "id" : "id",
        "channelId" : "channelId",
        "properties" : {
          "key" : "{}"
        }
      }, {
        "deleteAt" : 6,
        "icon" : "icon",
        "description" : "description",
        "updateAt" : 5,
        "title" : "title",
        "type" : "type",
        "createAt" : 0,
        "showDescription" : true,
        "createdBy" : "createdBy",
        "isTemplate" : true,
        "teamId" : "teamId",
        "cardProperties" : [ {
          "key" : "{}"
        }, {
          "key" : "{}"
        } ],
        "modifiedBy" : "modifiedBy",
        "templateVersion" : 1,
        "id" : "id",
        "channelId" : "channelId",
        "properties" : {
          "key" : "{}"
        }
      } ]
    }'

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            BoardsAndBlocks body = ; // BoardsAndBlocks |

            try {
                BoardsAndBlocks result = apiInstance.insertBoardsAndBlocks(body);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#insertBoardsAndBlocks");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            BoardsAndBlocks body = ; // BoardsAndBlocks |

            try {
                BoardsAndBlocks result = apiInstance.insertBoardsAndBlocks(body);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#insertBoardsAndBlocks");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    BoardsAndBlocks *body = ; //

    [apiInstance insertBoardsAndBlocksWith:body
                  completionHandler: ^(BoardsAndBlocks output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var body = ; // {BoardsAndBlocks}

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.insertBoardsAndBlocks(body, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class insertBoardsAndBlocksExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var body = new BoardsAndBlocks(); // BoardsAndBlocks |

                try {
                    BoardsAndBlocks result = apiInstance.insertBoardsAndBlocks(body);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.insertBoardsAndBlocks: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $body = ; // BoardsAndBlocks |

    try {
        $result = $api_instance->insertBoardsAndBlocks($body);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->insertBoardsAndBlocks: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $body = WWW::OPenAPIClient::Object::BoardsAndBlocks->new(); # BoardsAndBlocks |

    eval {
        my $result = $api_instance->insertBoardsAndBlocks(body => $body);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->insertBoardsAndBlocks: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    body =  # BoardsAndBlocks |

    try:
        api_response = api_instance.insert_boards_and_blocks(body)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->insertBoardsAndBlocks: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let body = ; // BoardsAndBlocks

        let mut context = DefaultApi::Context::default();
        let result = client.insertBoardsAndBlocks(body, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Body parameters

Name | Description
--- | ---
body * | the boards and blocks to create

## Responses

###

###

# joinBoard

Become a member of a board

    /boards/{boardID}/join

### Usage and SDK Samples

    curl -X POST \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/boards/{boardID}/join"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID

            try {
                BoardMember result = apiInstance.joinBoard(boardID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#joinBoard");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID

            try {
                BoardMember result = apiInstance.joinBoard(boardID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#joinBoard");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *boardID = boardID_example; // Board ID (default to null)

    [apiInstance joinBoardWith:boardID
                  completionHandler: ^(BoardMember output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var boardID = boardID_example; // {String} Board ID

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.joinBoard(boardID, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class joinBoardExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var boardID = boardID_example;  // String | Board ID (default to null)

                try {
                    BoardMember result = apiInstance.joinBoard(boardID);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.joinBoard: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $boardID = boardID_example; // String | Board ID

    try {
        $result = $api_instance->joinBoard($boardID);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->joinBoard: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $boardID = boardID_example; # String | Board ID

    eval {
        my $result = $api_instance->joinBoard(boardID => $boardID);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->joinBoard: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    boardID = boardID_example # String | Board ID (default to null)

    try:
        api_response = api_instance.join_board(boardID)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->joinBoard: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let boardID = boardID_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.joinBoard(boardID, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
boardID* | String Board ID Required

## Responses

###

###

###

###

# leaveBoard

Remove your own membership from a board

    /boards/{boardID}/leave

### Usage and SDK Samples

    curl -X POST \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/boards/{boardID}/leave"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID

            try {
                apiInstance.leaveBoard(boardID);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#leaveBoard");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID

            try {
                apiInstance.leaveBoard(boardID);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#leaveBoard");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *boardID = boardID_example; // Board ID (default to null)

    [apiInstance leaveBoardWith:boardID
                  completionHandler: ^(NSError* error) {
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var boardID = boardID_example; // {String} Board ID

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully.');
      }
    };
    api.leaveBoard(boardID, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class leaveBoardExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var boardID = boardID_example;  // String | Board ID (default to null)

                try {
                    apiInstance.leaveBoard(boardID);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.leaveBoard: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $boardID = boardID_example; // String | Board ID

    try {
        $api_instance->leaveBoard($boardID);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->leaveBoard: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $boardID = boardID_example; # String | Board ID

    eval {
        $api_instance->leaveBoard(boardID => $boardID);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->leaveBoard: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    boardID = boardID_example # String | Board ID (default to null)

    try:
        api_instance.leave_board(boardID)
    except ApiException as e:
        print("Exception when calling DefaultApi->leaveBoard: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let boardID = boardID_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.leaveBoard(boardID, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
boardID* | String Board ID Required

## Responses

###

###

###

###

# login

Login user

    /login

### Usage and SDK Samples

    curl -X POST \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "http://localhost/api/v2/login" \
     -d '{
      "password" : "password",
      "type" : "type",
      "email" : "email",
      "username" : "username"
    }'

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            LoginRequest body = ; // LoginRequest |

            try {
                LoginResponse result = apiInstance.login(body);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#login");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            LoginRequest body = ; // LoginRequest |

            try {
                LoginResponse result = apiInstance.login(body);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#login");
                e.printStackTrace();
            }
        }
    }

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    LoginRequest *body = ; //

    [apiInstance loginWith:body
                  completionHandler: ^(LoginResponse output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var body = ; // {LoginRequest}

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.login(body, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class loginExample
        {
            public void main()
            {

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var body = new LoginRequest(); // LoginRequest |

                try {
                    LoginResponse result = apiInstance.login(body);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.login: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $body = ; // LoginRequest |

    try {
        $result = $api_instance->login($body);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->login: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $body = WWW::OPenAPIClient::Object::LoginRequest->new(); # LoginRequest |

    eval {
        my $result = $api_instance->login(body => $body);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->login: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    body =  # LoginRequest |

    try:
        api_response = api_instance.login(body)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->login: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let body = ; // LoginRequest

        let mut context = DefaultApi::Context::default();
        let result = client.login(body, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Body parameters

Name | Description
--- | ---
body * | Login request

## Responses

###

###

###

# logout

Logout user

    /logout

### Usage and SDK Samples

    curl -X POST \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/logout"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();

            try {
                apiInstance.logout();
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#logout");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();

            try {
                apiInstance.logout();
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#logout");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];

    [apiInstance logoutWithCompletionHandler:
                  ^(NSError* error) {
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully.');
      }
    };
    api.logout(callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class logoutExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();

                try {
                    apiInstance.logout();
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.logout: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();

    try {
        $api_instance->logout();
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->logout: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

    eval {
        $api_instance->logout();
    };
    if ($@) {
        warn "Exception when calling DefaultApi->logout: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()

    try:
        api_instance.logout()
    except ApiException as e:
        print("Exception when calling DefaultApi->logout: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {

        let mut context = DefaultApi::Context::default();
        let result = client.logout(&context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

## Responses

###

###

# onboard

Onboards a user on Boards.

    /team/{teamID}/onboard

### Usage and SDK Samples

    curl -X POST \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/team/{teamID}/onboard"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String teamID = teamID_example; // String | Team ID

            try {
                inline_response_200 result = apiInstance.onboard(teamID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#onboard");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String teamID = teamID_example; // String | Team ID

            try {
                inline_response_200 result = apiInstance.onboard(teamID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#onboard");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *teamID = teamID_example; // Team ID (default to null)

    // Onboards a user on Boards.
    [apiInstance onboardWith:teamID
                  completionHandler: ^(inline_response_200 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var teamID = teamID_example; // {String} Team ID

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.onboard(teamID, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class onboardExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var teamID = teamID_example;  // String | Team ID (default to null)

                try {
                    // Onboards a user on Boards.
                    inline_response_200 result = apiInstance.onboard(teamID);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.onboard: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $teamID = teamID_example; // String | Team ID

    try {
        $result = $api_instance->onboard($teamID);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->onboard: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $teamID = teamID_example; # String | Team ID

    eval {
        my $result = $api_instance->onboard(teamID => $teamID);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->onboard: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    teamID = teamID_example # String | Team ID (default to null)

    try:
        # Onboards a user on Boards.
        api_response = api_instance.onboard(teamID)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->onboard: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let teamID = teamID_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.onboard(teamID, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
teamID* | String Team ID Required

## Responses

###

###

# patchBlock

Partially updates a block

    /boards/{boardID}/blocks/{blockID}

### Usage and SDK Samples

    curl -X PATCH \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "http://localhost/api/v2/boards/{boardID}/blocks/{blockID}" \
     -d '{
      "schema" : 0,
      "updatedFields" : {
        "key" : "{}"
      },
      "boardId" : "boardId",
      "title" : "title",
      "type" : "type",
      "deletedFields" : [ "deletedFields", "deletedFields" ],
      "parentId" : "parentId"
    }'

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID
            String blockID = blockID_example; // String | ID of block to patch
            BlockPatch body = ; // BlockPatch |

            try {
                apiInstance.patchBlock(boardID, blockID, body);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#patchBlock");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID
            String blockID = blockID_example; // String | ID of block to patch
            BlockPatch body = ; // BlockPatch |

            try {
                apiInstance.patchBlock(boardID, blockID, body);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#patchBlock");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *boardID = boardID_example; // Board ID (default to null)
    String *blockID = blockID_example; // ID of block to patch (default to null)
    BlockPatch *body = ; //

    [apiInstance patchBlockWith:boardID
        blockID:blockID
        body:body
                  completionHandler: ^(NSError* error) {
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var boardID = boardID_example; // {String} Board ID
    var blockID = blockID_example; // {String} ID of block to patch
    var body = ; // {BlockPatch}

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully.');
      }
    };
    api.patchBlock(boardID, blockID, body, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class patchBlockExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var boardID = boardID_example;  // String | Board ID (default to null)
                var blockID = blockID_example;  // String | ID of block to patch (default to null)
                var body = new BlockPatch(); // BlockPatch |

                try {
                    apiInstance.patchBlock(boardID, blockID, body);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.patchBlock: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $boardID = boardID_example; // String | Board ID
    $blockID = blockID_example; // String | ID of block to patch
    $body = ; // BlockPatch |

    try {
        $api_instance->patchBlock($boardID, $blockID, $body);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->patchBlock: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $boardID = boardID_example; # String | Board ID
    my $blockID = blockID_example; # String | ID of block to patch
    my $body = WWW::OPenAPIClient::Object::BlockPatch->new(); # BlockPatch |

    eval {
        $api_instance->patchBlock(boardID => $boardID, blockID => $blockID, body => $body);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->patchBlock: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    boardID = boardID_example # String | Board ID (default to null)
    blockID = blockID_example # String | ID of block to patch (default to null)
    body =  # BlockPatch |

    try:
        api_instance.patch_block(boardID, blockID, body)
    except ApiException as e:
        print("Exception when calling DefaultApi->patchBlock: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let boardID = boardID_example; // String
        let blockID = blockID_example; // String
        let body = ; // BlockPatch

        let mut context = DefaultApi::Context::default();
        let result = client.patchBlock(boardID, blockID, body, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
boardID* | String Board ID Required
blockID* | String ID of block to patch Required

Body parameters

Name | Description
--- | ---
body * | block patch to apply

## Responses

###

###

###

# patchBlocks

Partially updates batch of blocks

    /boards/{boardID}/blocks/

### Usage and SDK Samples

    curl -X PATCH \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "http://localhost/api/v2/boards/{boardID}/blocks/" \
     -d '{
      "block_patches" : [ {
        "schema" : 0,
        "updatedFields" : {
          "key" : "{}"
        },
        "boardId" : "boardId",
        "title" : "title",
        "type" : "type",
        "deletedFields" : [ "deletedFields", "deletedFields" ],
        "parentId" : "parentId"
      }, {
        "schema" : 0,
        "updatedFields" : {
          "key" : "{}"
        },
        "boardId" : "boardId",
        "title" : "title",
        "type" : "type",
        "deletedFields" : [ "deletedFields", "deletedFields" ],
        "parentId" : "parentId"
      } ],
      "block_ids" : [ "block_ids", "block_ids" ]
    }'

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Workspace ID
            BlockPatchBatch body = ; // BlockPatchBatch |

            try {
                apiInstance.patchBlocks(boardID, body);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#patchBlocks");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Workspace ID
            BlockPatchBatch body = ; // BlockPatchBatch |

            try {
                apiInstance.patchBlocks(boardID, body);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#patchBlocks");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *boardID = boardID_example; // Workspace ID (default to null)
    BlockPatchBatch *body = ; //

    [apiInstance patchBlocksWith:boardID
        body:body
                  completionHandler: ^(NSError* error) {
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var boardID = boardID_example; // {String} Workspace ID
    var body = ; // {BlockPatchBatch}

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully.');
      }
    };
    api.patchBlocks(boardID, body, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class patchBlocksExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var boardID = boardID_example;  // String | Workspace ID (default to null)
                var body = new BlockPatchBatch(); // BlockPatchBatch |

                try {
                    apiInstance.patchBlocks(boardID, body);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.patchBlocks: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $boardID = boardID_example; // String | Workspace ID
    $body = ; // BlockPatchBatch |

    try {
        $api_instance->patchBlocks($boardID, $body);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->patchBlocks: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $boardID = boardID_example; # String | Workspace ID
    my $body = WWW::OPenAPIClient::Object::BlockPatchBatch->new(); # BlockPatchBatch |

    eval {
        $api_instance->patchBlocks(boardID => $boardID, body => $body);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->patchBlocks: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    boardID = boardID_example # String | Workspace ID (default to null)
    body =  # BlockPatchBatch |

    try:
        api_instance.patch_blocks(boardID, body)
    except ApiException as e:
        print("Exception when calling DefaultApi->patchBlocks: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let boardID = boardID_example; // String
        let body = ; // BlockPatchBatch

        let mut context = DefaultApi::Context::default();
        let result = client.patchBlocks(boardID, body, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
boardID* | String Workspace ID Required

Body parameters

Name | Description
--- | ---
body * | block Ids and block patches to apply

## Responses

###

###

# patchBoard

Partially updates a board

    /boards/{boardID}

### Usage and SDK Samples

    curl -X PATCH \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "http://localhost/api/v2/boards/{boardID}" \
     -d '{
      "showDescription" : true,
      "updatedProperties" : {
        "key" : "{}"
      },
      "icon" : "icon",
      "deletedCardProperties" : [ "deletedCardProperties", "deletedCardProperties" ],
      "description" : "description",
      "updatedCardProperties" : [ {
        "key" : "{}"
      }, {
        "key" : "{}"
      } ],
      "title" : "title",
      "type" : "type",
      "deletedProperties" : [ "deletedProperties", "deletedProperties" ]
    }'

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID
            BoardPatch body = ; // BoardPatch |

            try {
                Board result = apiInstance.patchBoard(boardID, body);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#patchBoard");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID
            BoardPatch body = ; // BoardPatch |

            try {
                Board result = apiInstance.patchBoard(boardID, body);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#patchBoard");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *boardID = boardID_example; // Board ID (default to null)
    BoardPatch *body = ; //

    [apiInstance patchBoardWith:boardID
        body:body
                  completionHandler: ^(Board output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var boardID = boardID_example; // {String} Board ID
    var body = ; // {BoardPatch}

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.patchBoard(boardID, body, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class patchBoardExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var boardID = boardID_example;  // String | Board ID (default to null)
                var body = new BoardPatch(); // BoardPatch |

                try {
                    Board result = apiInstance.patchBoard(boardID, body);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.patchBoard: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $boardID = boardID_example; // String | Board ID
    $body = ; // BoardPatch |

    try {
        $result = $api_instance->patchBoard($boardID, $body);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->patchBoard: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $boardID = boardID_example; # String | Board ID
    my $body = WWW::OPenAPIClient::Object::BoardPatch->new(); # BoardPatch |

    eval {
        my $result = $api_instance->patchBoard(boardID => $boardID, body => $body);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->patchBoard: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    boardID = boardID_example # String | Board ID (default to null)
    body =  # BoardPatch |

    try:
        api_response = api_instance.patch_board(boardID, body)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->patchBoard: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let boardID = boardID_example; // String
        let body = ; // BoardPatch

        let mut context = DefaultApi::Context::default();
        let result = client.patchBoard(boardID, body, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
boardID* | String Board ID Required

Body parameters

Name | Description
--- | ---
body * | board patch to apply

## Responses

###

###

###

# patchBoardsAndBlocks

Patches a set of related boards and blocks

    /boards-and-blocks

### Usage and SDK Samples

    curl -X PATCH \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "http://localhost/api/v2/boards-and-blocks" \
     -d '{
      "boardIDs" : [ "boardIDs", "boardIDs" ],
      "boardPatches" : [ {
        "showDescription" : true,
        "updatedProperties" : {
          "key" : "{}"
        },
        "icon" : "icon",
        "deletedCardProperties" : [ "deletedCardProperties", "deletedCardProperties" ],
        "description" : "description",
        "updatedCardProperties" : [ {
          "key" : "{}"
        }, {
          "key" : "{}"
        } ],
        "title" : "title",
        "type" : "type",
        "deletedProperties" : [ "deletedProperties", "deletedProperties" ]
      }, {
        "showDescription" : true,
        "updatedProperties" : {
          "key" : "{}"
        },
        "icon" : "icon",
        "deletedCardProperties" : [ "deletedCardProperties", "deletedCardProperties" ],
        "description" : "description",
        "updatedCardProperties" : [ {
          "key" : "{}"
        }, {
          "key" : "{}"
        } ],
        "title" : "title",
        "type" : "type",
        "deletedProperties" : [ "deletedProperties", "deletedProperties" ]
      } ],
      "blockIDs" : [ "blockIDs", "blockIDs" ],
      "blockPatches" : [ {
        "schema" : 0,
        "updatedFields" : {
          "key" : "{}"
        },
        "boardId" : "boardId",
        "title" : "title",
        "type" : "type",
        "deletedFields" : [ "deletedFields", "deletedFields" ],
        "parentId" : "parentId"
      }, {
        "schema" : 0,
        "updatedFields" : {
          "key" : "{}"
        },
        "boardId" : "boardId",
        "title" : "title",
        "type" : "type",
        "deletedFields" : [ "deletedFields", "deletedFields" ],
        "parentId" : "parentId"
      } ]
    }'

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            PatchBoardsAndBlocks body = ; // PatchBoardsAndBlocks |

            try {
                BoardsAndBlocks result = apiInstance.patchBoardsAndBlocks(body);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#patchBoardsAndBlocks");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            PatchBoardsAndBlocks body = ; // PatchBoardsAndBlocks |

            try {
                BoardsAndBlocks result = apiInstance.patchBoardsAndBlocks(body);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#patchBoardsAndBlocks");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    PatchBoardsAndBlocks *body = ; //

    [apiInstance patchBoardsAndBlocksWith:body
                  completionHandler: ^(BoardsAndBlocks output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var body = ; // {PatchBoardsAndBlocks}

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.patchBoardsAndBlocks(body, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class patchBoardsAndBlocksExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var body = new PatchBoardsAndBlocks(); // PatchBoardsAndBlocks |

                try {
                    BoardsAndBlocks result = apiInstance.patchBoardsAndBlocks(body);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.patchBoardsAndBlocks: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $body = ; // PatchBoardsAndBlocks |

    try {
        $result = $api_instance->patchBoardsAndBlocks($body);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->patchBoardsAndBlocks: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $body = WWW::OPenAPIClient::Object::PatchBoardsAndBlocks->new(); # PatchBoardsAndBlocks |

    eval {
        my $result = $api_instance->patchBoardsAndBlocks(body => $body);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->patchBoardsAndBlocks: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    body =  # PatchBoardsAndBlocks |

    try:
        api_response = api_instance.patch_boards_and_blocks(body)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->patchBoardsAndBlocks: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let body = ; // PatchBoardsAndBlocks

        let mut context = DefaultApi::Context::default();
        let result = client.patchBoardsAndBlocks(body, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Body parameters

Name | Description
--- | ---
body * | the patches for the boards and blocks

## Responses

###

###

# postSharing

Sets sharing information for a board

    /boards/{boardID}/sharing

### Usage and SDK Samples

    curl -X POST \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "http://localhost/api/v2/boards/{boardID}/sharing" \
     -d '{
      "update_at" : 0,
      "modifiedBy" : "modifiedBy",
      "id" : "id",
      "enabled" : true,
      "token" : "token"
    }'

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID
            Sharing body = ; // Sharing |

            try {
                apiInstance.postSharing(boardID, body);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#postSharing");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID
            Sharing body = ; // Sharing |

            try {
                apiInstance.postSharing(boardID, body);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#postSharing");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *boardID = boardID_example; // Board ID (default to null)
    Sharing *body = ; //

    [apiInstance postSharingWith:boardID
        body:body
                  completionHandler: ^(NSError* error) {
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var boardID = boardID_example; // {String} Board ID
    var body = ; // {Sharing}

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully.');
      }
    };
    api.postSharing(boardID, body, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class postSharingExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var boardID = boardID_example;  // String | Board ID (default to null)
                var body = new Sharing(); // Sharing |

                try {
                    apiInstance.postSharing(boardID, body);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.postSharing: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $boardID = boardID_example; // String | Board ID
    $body = ; // Sharing |

    try {
        $api_instance->postSharing($boardID, $body);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->postSharing: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $boardID = boardID_example; # String | Board ID
    my $body = WWW::OPenAPIClient::Object::Sharing->new(); # Sharing |

    eval {
        $api_instance->postSharing(boardID => $boardID, body => $body);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->postSharing: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    boardID = boardID_example # String | Board ID (default to null)
    body =  # Sharing |

    try:
        api_instance.post_sharing(boardID, body)
    except ApiException as e:
        print("Exception when calling DefaultApi->postSharing: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let boardID = boardID_example; // String
        let body = ; // Sharing

        let mut context = DefaultApi::Context::default();
        let result = client.postSharing(boardID, body, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
boardID* | String Board ID Required

Body parameters

Name | Description
--- | ---
body * | sharing information for a root block

## Responses

###

###

# regenerateSignupToken

Regenerates the signup token for the root team

    /teams/{teamID}/regenerate_signup_token

### Usage and SDK Samples

    curl -X POST \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/teams/{teamID}/regenerate_signup_token"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String teamID = teamID_example; // String | Team ID

            try {
                apiInstance.regenerateSignupToken(teamID);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#regenerateSignupToken");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String teamID = teamID_example; // String | Team ID

            try {
                apiInstance.regenerateSignupToken(teamID);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#regenerateSignupToken");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *teamID = teamID_example; // Team ID (default to null)

    [apiInstance regenerateSignupTokenWith:teamID
                  completionHandler: ^(NSError* error) {
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var teamID = teamID_example; // {String} Team ID

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully.');
      }
    };
    api.regenerateSignupToken(teamID, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class regenerateSignupTokenExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var teamID = teamID_example;  // String | Team ID (default to null)

                try {
                    apiInstance.regenerateSignupToken(teamID);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.regenerateSignupToken: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $teamID = teamID_example; // String | Team ID

    try {
        $api_instance->regenerateSignupToken($teamID);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->regenerateSignupToken: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $teamID = teamID_example; # String | Team ID

    eval {
        $api_instance->regenerateSignupToken(teamID => $teamID);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->regenerateSignupToken: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    teamID = teamID_example # String | Team ID (default to null)

    try:
        api_instance.regenerate_signup_token(teamID)
    except ApiException as e:
        print("Exception when calling DefaultApi->regenerateSignupToken: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let teamID = teamID_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.regenerateSignupToken(teamID, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
teamID* | String Team ID Required

## Responses

###

###

# register

Register new user

    /register

### Usage and SDK Samples

    curl -X POST \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "http://localhost/api/v2/register" \
     -d '{
      "password" : "password",
      "email" : "email",
      "token" : "token",
      "username" : "username"
    }'

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            RegisterRequest body = ; // RegisterRequest |

            try {
                apiInstance.register(body);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#register");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            RegisterRequest body = ; // RegisterRequest |

            try {
                apiInstance.register(body);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#register");
                e.printStackTrace();
            }
        }
    }

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    RegisterRequest *body = ; //

    [apiInstance registerWith:body
                  completionHandler: ^(NSError* error) {
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var body = ; // {RegisterRequest}

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully.');
      }
    };
    api.register(body, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class registerExample
        {
            public void main()
            {

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var body = new RegisterRequest(); // RegisterRequest |

                try {
                    apiInstance.register(body);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.register: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $body = ; // RegisterRequest |

    try {
        $api_instance->register($body);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->register: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $body = WWW::OPenAPIClient::Object::RegisterRequest->new(); # RegisterRequest |

    eval {
        $api_instance->register(body => $body);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->register: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    body =  # RegisterRequest |

    try:
        api_instance.register(body)
    except ApiException as e:
        print("Exception when calling DefaultApi->register: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let body = ; // RegisterRequest

        let mut context = DefaultApi::Context::default();
        let result = client.register(body, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Body parameters

Name | Description
--- | ---
body * | Register request

## Responses

###

###

###

# searchBoards

Returns the boards that match with a search term

    /teams/{teamID}/boards/search

### Usage and SDK Samples

    curl -X GET \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/teams/{teamID}/boards/search?q=q_example"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String teamID = teamID_example; // String | Team ID
            String q = q_example; // String | The search term. Must have at least one character

            try {
                array[Board] result = apiInstance.searchBoards(teamID, q);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#searchBoards");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String teamID = teamID_example; // String | Team ID
            String q = q_example; // String | The search term. Must have at least one character

            try {
                array[Board] result = apiInstance.searchBoards(teamID, q);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#searchBoards");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *teamID = teamID_example; // Team ID (default to null)
    String *q = q_example; // The search term. Must have at least one character (default to null)

    [apiInstance searchBoardsWith:teamID
        q:q
                  completionHandler: ^(array[Board] output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var teamID = teamID_example; // {String} Team ID
    var q = q_example; // {String} The search term. Must have at least one character

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.searchBoards(teamID, q, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class searchBoardsExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var teamID = teamID_example;  // String | Team ID (default to null)
                var q = q_example;  // String | The search term. Must have at least one character (default to null)

                try {
                    array[Board] result = apiInstance.searchBoards(teamID, q);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.searchBoards: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $teamID = teamID_example; // String | Team ID
    $q = q_example; // String | The search term. Must have at least one character

    try {
        $result = $api_instance->searchBoards($teamID, $q);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->searchBoards: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $teamID = teamID_example; # String | Team ID
    my $q = q_example; # String | The search term. Must have at least one character

    eval {
        my $result = $api_instance->searchBoards(teamID => $teamID, q => $q);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->searchBoards: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    teamID = teamID_example # String | Team ID (default to null)
    q = q_example # String | The search term. Must have at least one character (default to null)

    try:
        api_response = api_instance.search_boards(teamID, q)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->searchBoards: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let teamID = teamID_example; // String
        let q = q_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.searchBoards(teamID, q, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
teamID* | String Team ID Required

Query parameters

Name | Description
--- | ---
q* | String The search term. Must have at least one character Required

## Responses

###

###

# undeleteBlock

Undeletes a block

    /boards/{boardID}/blocks/{blockID}/undelete

### Usage and SDK Samples

    curl -X POST \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/boards/{boardID}/blocks/{blockID}/undelete"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID
            String blockID = blockID_example; // String | ID of block to undelete

            try {
                BlockPatch result = apiInstance.undeleteBlock(boardID, blockID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#undeleteBlock");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID
            String blockID = blockID_example; // String | ID of block to undelete

            try {
                BlockPatch result = apiInstance.undeleteBlock(boardID, blockID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#undeleteBlock");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *boardID = boardID_example; // Board ID (default to null)
    String *blockID = blockID_example; // ID of block to undelete (default to null)

    [apiInstance undeleteBlockWith:boardID
        blockID:blockID
                  completionHandler: ^(BlockPatch output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var boardID = boardID_example; // {String} Board ID
    var blockID = blockID_example; // {String} ID of block to undelete

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.undeleteBlock(boardID, blockID, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class undeleteBlockExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var boardID = boardID_example;  // String | Board ID (default to null)
                var blockID = blockID_example;  // String | ID of block to undelete (default to null)

                try {
                    BlockPatch result = apiInstance.undeleteBlock(boardID, blockID);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.undeleteBlock: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $boardID = boardID_example; // String | Board ID
    $blockID = blockID_example; // String | ID of block to undelete

    try {
        $result = $api_instance->undeleteBlock($boardID, $blockID);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->undeleteBlock: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $boardID = boardID_example; # String | Board ID
    my $blockID = blockID_example; # String | ID of block to undelete

    eval {
        my $result = $api_instance->undeleteBlock(boardID => $boardID, blockID => $blockID);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->undeleteBlock: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    boardID = boardID_example # String | Board ID (default to null)
    blockID = blockID_example # String | ID of block to undelete (default to null)

    try:
        api_response = api_instance.undelete_block(boardID, blockID)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->undeleteBlock: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let boardID = boardID_example; // String
        let blockID = blockID_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.undeleteBlock(boardID, blockID, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
boardID* | String Board ID Required
blockID* | String ID of block to undelete Required

## Responses

###

###

###

# undeleteBoard

Undeletes a board

    /boards/{boardID}/undelete

### Usage and SDK Samples

    curl -X POST \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/boards/{boardID}/undelete"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | ID of board to undelete

            try {
                apiInstance.undeleteBoard(boardID);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#undeleteBoard");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | ID of board to undelete

            try {
                apiInstance.undeleteBoard(boardID);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#undeleteBoard");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *boardID = boardID_example; // ID of board to undelete (default to null)

    [apiInstance undeleteBoardWith:boardID
                  completionHandler: ^(NSError* error) {
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var boardID = boardID_example; // {String} ID of board to undelete

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully.');
      }
    };
    api.undeleteBoard(boardID, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class undeleteBoardExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var boardID = boardID_example;  // String | ID of board to undelete (default to null)

                try {
                    apiInstance.undeleteBoard(boardID);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.undeleteBoard: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $boardID = boardID_example; // String | ID of board to undelete

    try {
        $api_instance->undeleteBoard($boardID);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->undeleteBoard: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $boardID = boardID_example; # String | ID of board to undelete

    eval {
        $api_instance->undeleteBoard(boardID => $boardID);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->undeleteBoard: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    boardID = boardID_example # String | ID of board to undelete (default to null)

    try:
        api_instance.undelete_board(boardID)
    except ApiException as e:
        print("Exception when calling DefaultApi->undeleteBoard: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let boardID = boardID_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.undeleteBoard(boardID, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
boardID* | String ID of board to undelete Required

## Responses

###

###

# updateBlocks

Insert blocks. The specified IDs will only be used to link blocks with existing ones, the rest will be replaced by server generated IDs

    /boards/{boardID}/blocks

### Usage and SDK Samples

    curl -X POST \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "http://localhost/api/v2/boards/{boardID}/blocks" \
     -d '{
      "schema" : 1,
      "createdBy" : "createdBy",
      "deleteAt" : 6,
      "boardId" : "boardId",
      "updateAt" : 5,
      "modifiedBy" : "modifiedBy",
      "id" : "id",
      "fields" : {
        "key" : "{}"
      },
      "title" : "title",
      "type" : "type",
      "createAt" : 0,
      "parentId" : "parentId"
    }'

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID
            array[Block] body = ; // array[Block] |

            try {
                array[Block] result = apiInstance.updateBlocks(boardID, body);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#updateBlocks");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID
            array[Block] body = ; // array[Block] |

            try {
                array[Block] result = apiInstance.updateBlocks(boardID, body);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#updateBlocks");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *boardID = boardID_example; // Board ID (default to null)
    array[Block] *body = ; //

    [apiInstance updateBlocksWith:boardID
        body:body
                  completionHandler: ^(array[Block] output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var boardID = boardID_example; // {String} Board ID
    var body = ; // {array[Block]}

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.updateBlocks(boardID, body, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class updateBlocksExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var boardID = boardID_example;  // String | Board ID (default to null)
                var body = new array[Block](); // array[Block] |

                try {
                    array[Block] result = apiInstance.updateBlocks(boardID, body);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.updateBlocks: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $boardID = boardID_example; // String | Board ID
    $body = ; // array[Block] |

    try {
        $result = $api_instance->updateBlocks($boardID, $body);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->updateBlocks: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $boardID = boardID_example; # String | Board ID
    my $body = [WWW::OPenAPIClient::Object::array[Block]->new()]; # array[Block] |

    eval {
        my $result = $api_instance->updateBlocks(boardID => $boardID, body => $body);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->updateBlocks: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    boardID = boardID_example # String | Board ID (default to null)
    body =  # array[Block] |

    try:
        api_response = api_instance.update_blocks(boardID, body)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->updateBlocks: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let boardID = boardID_example; // String
        let body = ; // array[Block]

        let mut context = DefaultApi::Context::default();
        let result = client.updateBlocks(boardID, body, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
boardID* | String Board ID Required

Body parameters

Name | Description
--- | ---
body * | array of blocks to insert or update

## Responses

###

###

# updateCategory

Create a category for boards

    /teams/{teamID}/categories/{categoryID}

### Usage and SDK Samples

    curl -X PUT \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "http://localhost/api/v2/teams/{teamID}/categories/{categoryID}" \
     -d '{
      "deleteAt" : 6,
      "teamID" : "teamID",
      "name" : "name",
      "updateAt" : 1,
      "id" : "id",
      "userID" : "userID",
      "createAt" : 0
    }'

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String teamID = teamID_example; // String | Team ID
            String categoryID = categoryID_example; // String | Category ID
            Category body = ; // Category |

            try {
                Category result = apiInstance.updateCategory(teamID, categoryID, body);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#updateCategory");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String teamID = teamID_example; // String | Team ID
            String categoryID = categoryID_example; // String | Category ID
            Category body = ; // Category |

            try {
                Category result = apiInstance.updateCategory(teamID, categoryID, body);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#updateCategory");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *teamID = teamID_example; // Team ID (default to null)
    String *categoryID = categoryID_example; // Category ID (default to null)
    Category *body = ; //

    [apiInstance updateCategoryWith:teamID
        categoryID:categoryID
        body:body
                  completionHandler: ^(Category output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var teamID = teamID_example; // {String} Team ID
    var categoryID = categoryID_example; // {String} Category ID
    var body = ; // {Category}

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.updateCategory(teamID, categoryID, body, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class updateCategoryExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var teamID = teamID_example;  // String | Team ID (default to null)
                var categoryID = categoryID_example;  // String | Category ID (default to null)
                var body = new Category(); // Category |

                try {
                    Category result = apiInstance.updateCategory(teamID, categoryID, body);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.updateCategory: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $teamID = teamID_example; // String | Team ID
    $categoryID = categoryID_example; // String | Category ID
    $body = ; // Category |

    try {
        $result = $api_instance->updateCategory($teamID, $categoryID, $body);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->updateCategory: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $teamID = teamID_example; # String | Team ID
    my $categoryID = categoryID_example; # String | Category ID
    my $body = WWW::OPenAPIClient::Object::Category->new(); # Category |

    eval {
        my $result = $api_instance->updateCategory(teamID => $teamID, categoryID => $categoryID, body => $body);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->updateCategory: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    teamID = teamID_example # String | Team ID (default to null)
    categoryID = categoryID_example # String | Category ID (default to null)
    body =  # Category |

    try:
        api_response = api_instance.update_category(teamID, categoryID, body)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->updateCategory: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let teamID = teamID_example; // String
        let categoryID = categoryID_example; // String
        let body = ; // Category

        let mut context = DefaultApi::Context::default();
        let result = client.updateCategory(teamID, categoryID, body, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
teamID* | String Team ID Required
categoryID* | String Category ID Required

Body parameters

Name | Description
--- | ---
body * | category to update

## Responses

###

###

# updateCategoryBoard

Set the category of a board

    /teams/{teamID}/categories/{categoryID}/boards/{boardID}

### Usage and SDK Samples

    curl -X POST \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/teams/{teamID}/categories/{categoryID}/boards/{boardID}"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String teamID = teamID_example; // String | Team ID
            String categoryID = categoryID_example; // String | Category ID
            String boardID = boardID_example; // String | Board ID

            try {
                apiInstance.updateCategoryBoard(teamID, categoryID, boardID);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#updateCategoryBoard");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String teamID = teamID_example; // String | Team ID
            String categoryID = categoryID_example; // String | Category ID
            String boardID = boardID_example; // String | Board ID

            try {
                apiInstance.updateCategoryBoard(teamID, categoryID, boardID);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#updateCategoryBoard");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *teamID = teamID_example; // Team ID (default to null)
    String *categoryID = categoryID_example; // Category ID (default to null)
    String *boardID = boardID_example; // Board ID (default to null)

    [apiInstance updateCategoryBoardWith:teamID
        categoryID:categoryID
        boardID:boardID
                  completionHandler: ^(NSError* error) {
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var teamID = teamID_example; // {String} Team ID
    var categoryID = categoryID_example; // {String} Category ID
    var boardID = boardID_example; // {String} Board ID

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully.');
      }
    };
    api.updateCategoryBoard(teamID, categoryID, boardID, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class updateCategoryBoardExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var teamID = teamID_example;  // String | Team ID (default to null)
                var categoryID = categoryID_example;  // String | Category ID (default to null)
                var boardID = boardID_example;  // String | Board ID (default to null)

                try {
                    apiInstance.updateCategoryBoard(teamID, categoryID, boardID);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.updateCategoryBoard: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $teamID = teamID_example; // String | Team ID
    $categoryID = categoryID_example; // String | Category ID
    $boardID = boardID_example; // String | Board ID

    try {
        $api_instance->updateCategoryBoard($teamID, $categoryID, $boardID);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->updateCategoryBoard: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $teamID = teamID_example; # String | Team ID
    my $categoryID = categoryID_example; # String | Category ID
    my $boardID = boardID_example; # String | Board ID

    eval {
        $api_instance->updateCategoryBoard(teamID => $teamID, categoryID => $categoryID, boardID => $boardID);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->updateCategoryBoard: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    teamID = teamID_example # String | Team ID (default to null)
    categoryID = categoryID_example # String | Category ID (default to null)
    boardID = boardID_example # String | Board ID (default to null)

    try:
        api_instance.update_category_board(teamID, categoryID, boardID)
    except ApiException as e:
        print("Exception when calling DefaultApi->updateCategoryBoard: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let teamID = teamID_example; // String
        let categoryID = categoryID_example; // String
        let boardID = boardID_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.updateCategoryBoard(teamID, categoryID, boardID, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
teamID* | String Team ID Required
categoryID* | String Category ID Required
boardID* | String Board ID Required

## Responses

###

###

# updateMember

Updates a board member

    /boards/{boardID}/members/{userID}

### Usage and SDK Samples

    curl -X PUT \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "http://localhost/api/v2/boards/{boardID}/members/{userID}" \
     -d '{
      "schemeAdmin" : true,
      "schemeCommenter" : true,
      "schemeViewer" : true,
      "roles" : "roles",
      "schemeEditor" : true,
      "boardId" : "boardId",
      "userId" : "userId"
    }'

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID
            String userID = userID_example; // String | User ID
            BoardMember body = ; // BoardMember |

            try {
                BoardMember result = apiInstance.updateMember(boardID, userID, body);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#updateMember");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String boardID = boardID_example; // String | Board ID
            String userID = userID_example; // String | User ID
            BoardMember body = ; // BoardMember |

            try {
                BoardMember result = apiInstance.updateMember(boardID, userID, body);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#updateMember");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *boardID = boardID_example; // Board ID (default to null)
    String *userID = userID_example; // User ID (default to null)
    BoardMember *body = ; //

    [apiInstance updateMemberWith:boardID
        userID:userID
        body:body
                  completionHandler: ^(BoardMember output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var boardID = boardID_example; // {String} Board ID
    var userID = userID_example; // {String} User ID
    var body = ; // {BoardMember}

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.updateMember(boardID, userID, body, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class updateMemberExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var boardID = boardID_example;  // String | Board ID (default to null)
                var userID = userID_example;  // String | User ID (default to null)
                var body = new BoardMember(); // BoardMember |

                try {
                    BoardMember result = apiInstance.updateMember(boardID, userID, body);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.updateMember: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $boardID = boardID_example; // String | Board ID
    $userID = userID_example; // String | User ID
    $body = ; // BoardMember |

    try {
        $result = $api_instance->updateMember($boardID, $userID, $body);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->updateMember: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $boardID = boardID_example; # String | Board ID
    my $userID = userID_example; # String | User ID
    my $body = WWW::OPenAPIClient::Object::BoardMember->new(); # BoardMember |

    eval {
        my $result = $api_instance->updateMember(boardID => $boardID, userID => $userID, body => $body);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->updateMember: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    boardID = boardID_example # String | Board ID (default to null)
    userID = userID_example # String | User ID (default to null)
    body =  # BoardMember |

    try:
        api_response = api_instance.update_member(boardID, userID, body)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->updateMember: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let boardID = boardID_example; // String
        let userID = userID_example; // String
        let body = ; // BoardMember

        let mut context = DefaultApi::Context::default();
        let result = client.updateMember(boardID, userID, body, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
boardID* | String Board ID Required
userID* | String User ID Required

Body parameters

Name | Description
--- | ---
body * | membership to replace the current one with

## Responses

###

###

# updateUserConfig

Updates user config

    /users/{userID}/config

### Usage and SDK Samples

    curl -X PATCH \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "http://localhost/api/v2/users/{userID}/config" \
     -d '{
      "updatedFields" : {
        "key" : "updatedFields"
      },
      "deletedFields" : [ "deletedFields", "deletedFields" ]
    }'

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String userID = userID_example; // String | User ID
            UserPropPatch body = ; // UserPropPatch |

            try {
                apiInstance.updateUserConfig(userID, body);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#updateUserConfig");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String userID = userID_example; // String | User ID
            UserPropPatch body = ; // UserPropPatch |

            try {
                apiInstance.updateUserConfig(userID, body);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#updateUserConfig");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *userID = userID_example; // User ID (default to null)
    UserPropPatch *body = ; //

    [apiInstance updateUserConfigWith:userID
        body:body
                  completionHandler: ^(NSError* error) {
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var userID = userID_example; // {String} User ID
    var body = ; // {UserPropPatch}

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully.');
      }
    };
    api.updateUserConfig(userID, body, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class updateUserConfigExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var userID = userID_example;  // String | User ID (default to null)
                var body = new UserPropPatch(); // UserPropPatch |

                try {
                    apiInstance.updateUserConfig(userID, body);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.updateUserConfig: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $userID = userID_example; // String | User ID
    $body = ; // UserPropPatch |

    try {
        $api_instance->updateUserConfig($userID, $body);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->updateUserConfig: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $userID = userID_example; # String | User ID
    my $body = WWW::OPenAPIClient::Object::UserPropPatch->new(); # UserPropPatch |

    eval {
        $api_instance->updateUserConfig(userID => $userID, body => $body);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->updateUserConfig: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    userID = userID_example # String | User ID (default to null)
    body =  # UserPropPatch |

    try:
        api_instance.update_user_config(userID, body)
    except ApiException as e:
        print("Exception when calling DefaultApi->updateUserConfig: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let userID = userID_example; // String
        let body = ; // UserPropPatch

        let mut context = DefaultApi::Context::default();
        let result = client.updateUserConfig(userID, body, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
userID* | String User ID Required

Body parameters

Name | Description
--- | ---
body * | User config patch to apply

## Responses

###

###

# uploadFile

Upload a binary file, attached to a root block

    /teams/{teamID}/boards/{boardID}/files

### Usage and SDK Samples

    curl -X POST \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     -H "Content-Type: multipart/form-data" \
     "http://localhost/api/v2/teams/{teamID}/boards/{boardID}/files"

    import org.openapitools.client.*;
    import org.openapitools.client.auth.*;
    import org.openapitools.client.model.*;
    import org.openapitools.client.api.DefaultApi;

    import java.io.File;
    import java.util.*;

    public class DefaultApiExample {
        public static void main(String[] args) {
            ApiClient defaultClient = Configuration.getDefaultApiClient();

            // Configure API key authorization: BearerAuth
            ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
            BearerAuth.setApiKey("YOUR API KEY");
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //BearerAuth.setApiKeyPrefix("Token");

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String teamID = teamID_example; // String | ID of the team
            String boardID = boardID_example; // String | Board ID
            File uploaded file = BINARY_DATA_HERE; // File | The file to upload

            try {
                FileUploadResponse result = apiInstance.uploadFile(teamID, boardID, uploaded file);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#uploadFile");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String teamID = teamID_example; // String | ID of the team
            String boardID = boardID_example; // String | Board ID
            File uploaded file = BINARY_DATA_HERE; // File | The file to upload

            try {
                FileUploadResponse result = apiInstance.uploadFile(teamID, boardID, uploaded file);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#uploadFile");
                e.printStackTrace();
            }
        }
    }

    Configuration *apiConfig = [Configuration sharedConfig];

    // Configure API key authorization: (authentication scheme: BearerAuth)
    [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *teamID = teamID_example; // ID of the team (default to null)
    String *boardID = boardID_example; // Board ID (default to null)
    File *uploaded file = BINARY_DATA_HERE; // The file to upload (optional) (default to null)

    [apiInstance uploadFileWith:teamID
        boardID:boardID
        uploaded file:uploaded file
                  completionHandler: ^(FileUploadResponse output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var FocalboardServer = require('focalboard_server');
    var defaultClient = FocalboardServer.ApiClient.instance;

    // Configure API key authorization: BearerAuth
    var BearerAuth = defaultClient.authentications['BearerAuth'];
    BearerAuth.apiKey = "YOUR API KEY";
    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
    //BearerAuth.apiKeyPrefix['Authorization'] = "Token";

    // Create an instance of the API class
    var api = new FocalboardServer.DefaultApi()
    var teamID = teamID_example; // {String} ID of the team
    var boardID = boardID_example; // {String} Board ID
    var opts = {
      'uploaded file': BINARY_DATA_HERE // {File} The file to upload
    };

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.uploadFile(teamID, boardID, opts, callback);

    using System;
    using System.Diagnostics;
    using Org.OpenAPITools.Api;
    using Org.OpenAPITools.Client;
    using Org.OpenAPITools.Model;

    namespace Example
    {
        public class uploadFileExample
        {
            public void main()
            {
                // Configure API key authorization: BearerAuth
                Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var teamID = teamID_example;  // String | ID of the team (default to null)
                var boardID = boardID_example;  // String | Board ID (default to null)
                var uploaded file = BINARY_DATA_HERE;  // File | The file to upload (optional)  (default to null)

                try {
                    FileUploadResponse result = apiInstance.uploadFile(teamID, boardID, uploaded file);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.uploadFile: " + e.Message );
                }
            }
        }
    }

    <?php
    require_once(__DIR__ . '/vendor/autoload.php');

    // Configure API key authorization: BearerAuth
    OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    // OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $teamID = teamID_example; // String | ID of the team
    $boardID = boardID_example; // String | Board ID
    $uploaded file = BINARY_DATA_HERE; // File | The file to upload

    try {
        $result = $api_instance->uploadFile($teamID, $boardID, $uploaded file);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->uploadFile: ', $e->getMessage(), PHP_EOL;
    }
    ?>

    use Data::Dumper;
    use WWW::OPenAPIClient::Configuration;
    use WWW::OPenAPIClient::DefaultApi;

    # Configure API key authorization: BearerAuth
    $WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
    # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    #$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $teamID = teamID_example; # String | ID of the team
    my $boardID = boardID_example; # String | Board ID
    my $uploaded file = BINARY_DATA_HERE; # File | The file to upload

    eval {
        my $result = $api_instance->uploadFile(teamID => $teamID, boardID => $boardID, uploaded file => $uploaded file);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->uploadFile: $@\n";
    }

    from __future__ import print_statement
    import time
    import openapi_client
    from openapi_client.rest import ApiException
    from pprint import pprint

    # Configure API key authorization: BearerAuth
    openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
    # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
    # openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

    # Create an instance of the API class
    api_instance = openapi_client.DefaultApi()
    teamID = teamID_example # String | ID of the team (default to null)
    boardID = boardID_example # String | Board ID (default to null)
    uploaded file = BINARY_DATA_HERE # File | The file to upload (optional) (default to null)

    try:
        api_response = api_instance.upload_file(teamID, boardID, uploaded file=uploaded file)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->uploadFile: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let teamID = teamID_example; // String
        let boardID = boardID_example; // String
        let uploaded file = BINARY_DATA_HERE; // File

        let mut context = DefaultApi::Context::default();
        let result = client.uploadFile(teamID, boardID, uploaded file, &context).wait();

        println!("{:?}", result);
    }

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
teamID* | String ID of the team Required
boardID* | String Board ID Required

Form parameters

Name | Description
--- | ---
uploaded file | File (binary) The file to upload

## Responses

###

###

###