# Focalboard Server

## API and SDK Documentation

Version: 2.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 ''

    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
            Object body = Object; // Object |

            try {
                Object 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
            Object body = Object; // Object |

            try {
                Object 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)
    Object *body = Object; //

    [apiInstance addMemberWith:boardID
        body:body
                  completionHandler: ^(Object 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 = Object; // {Object}

    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 = Object;  // Object |

                try {
                    Object 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 = Object; // Object |

    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::Object->new(); # Object |

    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 = Object # Object |

    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 = Object; // Object

        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 ''

    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
            Object body = Object; // Object |

            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
            Object body = Object; // Object |

            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)
    Object *body = Object; //

    [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 = Object; // {Object}

    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 = Object;  // Object |

                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 = Object; // Object |

    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::Object->new(); # Object |

    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 = Object # Object |

    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 = Object; // Object

        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

###

###

###

# cloudLimits

Fetches the cloud limits of the server.

    /limits

### Usage and SDK Samples

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

    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 {
                Object result = apiInstance.cloudLimits();
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#cloudLimits");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

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

            try {
                Object result = apiInstance.cloudLimits();
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#cloudLimits");
                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];

    // Fetches the cloud limits of the server.
    [apiInstance cloudLimitsWithCompletionHandler:
                  ^(Object 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.cloudLimits(callback);

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

    namespace Example
    {
        public class cloudLimitsExample
        {
            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 {
                    // Fetches the cloud limits of the server.
                    Object result = apiInstance.cloudLimits();
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.cloudLimits: " + 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->cloudLimits();
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->cloudLimits: ', $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->cloudLimits();
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->cloudLimits: $@\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:
        # Fetches the cloud limits of the server.
        api_response = api_instance.cloud_limits()
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->cloudLimits: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {

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

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

## Scopes

## Parameters

## 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 ''

    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();
            Object body = Object; // Object |

            try {
                Object 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();
            Object body = Object; // Object |

            try {
                Object 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];
    Object *body = Object; //

    [apiInstance createBoardWith:body
                  completionHandler: ^(Object 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 = Object; // {Object}

    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 = Object;  // Object |

                try {
                    Object 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 = Object; // Object |

    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::Object->new(); # Object |

    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 = Object # Object |

    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 = Object; // Object

        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

###

###

# createCard

Creates a new card for the specified board.

    /boards/{boardID}/cards

### 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}/cards?disable_notify=" \
     -d ''

    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
            Object body = Object; // Object |
            oas_any_type_not_mapped disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk data inserting)

            try {
                Object result = apiInstance.createCard(boardID, body, disableNotify);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#createCard");
                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
            Object body = Object; // Object |
            oas_any_type_not_mapped disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk data inserting)

            try {
                Object result = apiInstance.createCard(boardID, body, disableNotify);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#createCard");
                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)
    Object *body = Object; //
    oas_any_type_not_mapped *disableNotify = ; // Disables notifications (for bulk data inserting) (optional) (default to null)

    // Creates a new card for the specified board.
    [apiInstance createCardWith:boardID
        body:body
        disableNotify:disableNotify
                  completionHandler: ^(Object 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 = Object; // {Object}
    var opts = {
      'disableNotify':  // {oas_any_type_not_mapped} Disables notifications (for bulk data inserting)
    };

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

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

    namespace Example
    {
        public class createCardExample
        {
            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 = Object;  // Object |
                var disableNotify = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | Disables notifications (for bulk data inserting) (optional)  (default to null)

                try {
                    // Creates a new card for the specified board.
                    Object result = apiInstance.createCard(boardID, body, disableNotify);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.createCard: " + 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 = Object; // Object |
    $disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk data inserting)

    try {
        $result = $api_instance->createCard($boardID, $body, $disableNotify);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->createCard: ', $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::Object->new(); # Object |
    my $disableNotify = ; # oas_any_type_not_mapped | Disables notifications (for bulk data inserting)

    eval {
        my $result = $api_instance->createCard(boardID => $boardID, body => $body, disableNotify => $disableNotify);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->createCard: $@\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 = Object # Object |
    disableNotify =  # oas_any_type_not_mapped | Disables notifications (for bulk data inserting) (optional) (default to null)

    try:
        # Creates a new card for the specified board.
        api_response = api_instance.create_card(boardID, body, disableNotify=disableNotify)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->createCard: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let boardID = boardID_example; // String
        let body = Object; // Object
        let disableNotify = ; // oas_any_type_not_mapped

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

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

## Scopes

## Parameters

Path parameters

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

Body parameters

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

Query parameters

Name | Description
--- | ---
disable_notify | oas_any_type_not_mapped Disables notifications (for bulk data inserting)

## 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 ''

    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
            Object body = Object; // Object |

            try {
                Object 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
            Object body = Object; // Object |

            try {
                Object 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)
    Object *body = Object; //

    [apiInstance createCategoryWith:teamID
        body:body
                  completionHandler: ^(Object 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 = Object; // {Object}

    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 = Object;  // Object |

                try {
                    Object 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 = Object; // Object |

    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::Object->new(); # Object |

    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 = Object # Object |

    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 = Object; // Object

        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 ''

    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();
            Object body = Object; // Object |

            try {
                Object 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();
            Object body = Object; // Object |

            try {
                Object 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];
    Object *body = Object; //

    // Creates a subscription to a block for a user. The user will receive change notifications for the block.
    [apiInstance createSubscriptionWith:body
                  completionHandler: ^(Object 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 = Object; // {Object}

    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 = Object;  // Object |

                try {
                    // Creates a subscription to a block for a user. The user will receive change notifications for the block.
                    Object 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 = Object; // Object |

    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::Object->new(); # Object |

    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 = Object # Object |

    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 = Object; // Object

        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}?disable_notify="

    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
            oas_any_type_not_mapped disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk deletion)

            try {
                apiInstance.deleteBlock(boardID, blockID, disableNotify);
            } 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
            oas_any_type_not_mapped disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk deletion)

            try {
                apiInstance.deleteBlock(boardID, blockID, disableNotify);
            } 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)
    oas_any_type_not_mapped *disableNotify = ; // Disables notifications (for bulk deletion) (optional) (default to null)

    [apiInstance deleteBlockWith:boardID
        blockID:blockID
        disableNotify:disableNotify
                  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 opts = {
      'disableNotify':  // {oas_any_type_not_mapped} Disables notifications (for bulk deletion)
    };

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully.');
      }
    };
    api.deleteBlock(boardID, blockID, opts, 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)
                var disableNotify = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | Disables notifications (for bulk deletion) (optional)  (default to null)

                try {
                    apiInstance.deleteBlock(boardID, blockID, disableNotify);
                } 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
    $disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk deletion)

    try {
        $api_instance->deleteBlock($boardID, $blockID, $disableNotify);
    } 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
    my $disableNotify = ; # oas_any_type_not_mapped | Disables notifications (for bulk deletion)

    eval {
        $api_instance->deleteBlock(boardID => $boardID, blockID => $blockID, disableNotify => $disableNotify);
    };
    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)
    disableNotify =  # oas_any_type_not_mapped | Disables notifications (for bulk deletion) (optional) (default to null)

    try:
        api_instance.delete_block(boardID, blockID, disableNotify=disableNotify)
    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 disableNotify = ; // oas_any_type_not_mapped

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

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

## Scopes

## Parameters

Path parameters

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

Query parameters

Name | Description
--- | ---
disable_notify | oas_any_type_not_mapped Disables notifications (for bulk deletion)

## 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 ''

    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();
            Object body = Object; // Object |

            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();
            Object body = Object; // Object |

            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];
    Object *body = Object; //

    [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 = Object; // {Object}

    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 = Object;  // Object |

                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 = Object; // Object |

    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::Object->new(); # Object |

    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 = Object # Object |

    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 = Object; // Object

        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[Object] 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[Object] 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[Object] 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[Object] 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 {
                Object 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 {
                Object 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: ^(Object 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 {
                    Object 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[Object] 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[Object] 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[Object] 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[Object] 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 {
                Object 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 {
                Object 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: ^(Object 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 {
                    Object 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 {
                Object 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 {
                Object 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: ^(Object 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 {
                    Object 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[Object] 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[Object] 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[Object] 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[Object] 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

###

###

# getCard

Fetches the specified card.

    /cards/{cardID}

### Usage and SDK Samples

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

    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 cardID = cardID_example; // String | Card ID

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

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String cardID = cardID_example; // String | Card ID

            try {
                Object result = apiInstance.getCard(cardID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getCard");
                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 *cardID = cardID_example; // Card ID (default to null)

    // Fetches the specified card.
    [apiInstance getCardWith:cardID
                  completionHandler: ^(Object 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 cardID = cardID_example; // {String} Card ID

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

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

    namespace Example
    {
        public class getCardExample
        {
            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 cardID = cardID_example;  // String | Card ID (default to null)

                try {
                    // Fetches the specified card.
                    Object result = apiInstance.getCard(cardID);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getCard: " + 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();
    $cardID = cardID_example; // String | Card ID

    try {
        $result = $api_instance->getCard($cardID);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getCard: ', $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 $cardID = cardID_example; # String | Card ID

    eval {
        my $result = $api_instance->getCard(cardID => $cardID);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getCard: $@\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()
    cardID = cardID_example # String | Card ID (default to null)

    try:
        # Fetches the specified card.
        api_response = api_instance.get_card(cardID)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getCard: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let cardID = cardID_example; // String

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

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

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
cardID* | String Card ID Required

## Responses

###

###

# getCards

Fetches cards for the specified board.

    /boards/{boardID}/cards

### Usage and SDK Samples

    curl -X GET \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/boards/{boardID}/cards?page=56&per_page=56"

    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
            Integer page = 56; // Integer | The page to select (default=0)
            Integer perPage = 56; // Integer | Number of cards to return per page(default=100)

            try {
                array[Object] result = apiInstance.getCards(boardID, page, perPage);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getCards");
                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
            Integer page = 56; // Integer | The page to select (default=0)
            Integer perPage = 56; // Integer | Number of cards to return per page(default=100)

            try {
                array[Object] result = apiInstance.getCards(boardID, page, perPage);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getCards");
                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)
    Integer *page = 56; // The page to select (default=0) (optional) (default to null)
    Integer *perPage = 56; // Number of cards to return per page(default=100) (optional) (default to null)

    // Fetches cards for the specified board.
    [apiInstance getCardsWith:boardID
        page:page
        perPage:perPage
                  completionHandler: ^(array[Object] 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 = {
      'page': 56, // {Integer} The page to select (default=0)
      'perPage': 56 // {Integer} Number of cards to return per page(default=100)
    };

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

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

    namespace Example
    {
        public class getCardsExample
        {
            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 page = 56;  // Integer | The page to select (default=0) (optional)  (default to null)
                var perPage = 56;  // Integer | Number of cards to return per page(default=100) (optional)  (default to null)

                try {
                    // Fetches cards for the specified board.
                    array[Object] result = apiInstance.getCards(boardID, page, perPage);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getCards: " + 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
    $page = 56; // Integer | The page to select (default=0)
    $perPage = 56; // Integer | Number of cards to return per page(default=100)

    try {
        $result = $api_instance->getCards($boardID, $page, $perPage);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getCards: ', $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 $page = 56; # Integer | The page to select (default=0)
    my $perPage = 56; # Integer | Number of cards to return per page(default=100)

    eval {
        my $result = $api_instance->getCards(boardID => $boardID, page => $page, perPage => $perPage);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getCards: $@\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)
    page = 56 # Integer | The page to select (default=0) (optional) (default to null)
    perPage = 56 # Integer | Number of cards to return per page(default=100) (optional) (default to null)

    try:
        # Fetches cards for the specified board.
        api_response = api_instance.get_cards(boardID, page=page, perPage=perPage)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getCards: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let boardID = boardID_example; // String
        let page = 56; // Integer
        let perPage = 56; // Integer

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

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

## Scopes

## Parameters

Path parameters

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

Query parameters

Name | Description
--- | ---
page | Integer The page to select (default=0)
per_page | Integer Number of cards to return per page(default=100)

## Responses

###

###

# getChannel

Returns the requested channel

    /teams/{teamID}/channels/{channelID}

### Usage and SDK Samples

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

    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 channelID = channelID_example; // String | Channel ID

            try {
                array[Channel] result = apiInstance.getChannel(teamID, channelID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getChannel");
                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 channelID = channelID_example; // String | Channel ID

            try {
                array[Channel] result = apiInstance.getChannel(teamID, channelID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getChannel");
                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 *channelID = channelID_example; // Channel ID (default to null)

    [apiInstance getChannelWith:teamID
        channelID:channelID
                  completionHandler: ^(array[Channel] 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 channelID = channelID_example; // {String} Channel ID

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

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

    namespace Example
    {
        public class getChannelExample
        {
            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 channelID = channelID_example;  // String | Channel ID (default to null)

                try {
                    array[Channel] result = apiInstance.getChannel(teamID, channelID);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getChannel: " + 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
    $channelID = channelID_example; // String | Channel ID

    try {
        $result = $api_instance->getChannel($teamID, $channelID);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getChannel: ', $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 $channelID = channelID_example; # String | Channel ID

    eval {
        my $result = $api_instance->getChannel(teamID => $teamID, channelID => $channelID);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getChannel: $@\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)
    channelID = channelID_example # String | Channel ID (default to null)

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

    extern crate DefaultApi;

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

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

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

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
teamID* | String Team ID Required
channelID* | String Channel 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 {
                Object 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 {
                Object 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:
                  ^(Object 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 {
                    Object 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

###

###

# getFile

Returns the contents of an uploaded file

    /files/teams/{teamID}/{boardID}/{filename}

### Usage and SDK Samples

    curl -X GET \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json,image/jpg,image/png,image/gif" \
     "http://localhost/api/v2/files/teams/{teamID}/{boardID}/{filename}"

    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 boardID = boardID_example; // String | Board ID
            String filename = filename_example; // String | name of the file

            try {
                apiInstance.getFile(teamID, boardID, filename);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getFile");
                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 boardID = boardID_example; // String | Board ID
            String filename = filename_example; // String | name of the file

            try {
                apiInstance.getFile(teamID, boardID, filename);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getFile");
                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 *boardID = boardID_example; // Board ID (default to null)
    String *filename = filename_example; // name of the file (default to null)

    [apiInstance getFileWith:teamID
        boardID:boardID
        filename:filename
                  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 boardID = boardID_example; // {String} Board ID
    var filename = filename_example; // {String} name of the file

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

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

    namespace Example
    {
        public class getFileExample
        {
            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 boardID = boardID_example;  // String | Board ID (default to null)
                var filename = filename_example;  // String | name of the file (default to null)

                try {
                    apiInstance.getFile(teamID, boardID, filename);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getFile: " + 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
    $boardID = boardID_example; // String | Board ID
    $filename = filename_example; // String | name of the file

    try {
        $api_instance->getFile($teamID, $boardID, $filename);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getFile: ', $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 $boardID = boardID_example; # String | Board ID
    my $filename = filename_example; # String | name of the file

    eval {
        $api_instance->getFile(teamID => $teamID, boardID => $boardID, filename => $filename);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getFile: $@\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)
    boardID = boardID_example # String | Board ID (default to null)
    filename = filename_example # String | name of the file (default to null)

    try:
        api_instance.get_file(teamID, boardID, filename)
    except ApiException as e:
        print("Exception when calling DefaultApi->getFile: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let teamID = teamID_example; // String
        let boardID = boardID_example; // String
        let filename = filename_example; // String

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

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

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
teamID* | String Team ID Required
boardID* | String Board ID Required
filename* | String name of the file Required

## 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 {
                Object 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 {
                Object 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:
                  ^(Object 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 {
                    Object 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[Object] 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[Object] 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[Object] 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[Object] 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[Object] 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[Object] 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[Object] 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[Object] 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 {
                Object 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 {
                Object 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: ^(Object 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 {
                    Object 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[Object] 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[Object] 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[Object] 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[Object] 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 {
                Object 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 {
                Object 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: ^(Object 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 {
                    Object 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&exclude_bots=true"

    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
            Boolean excludeBots = true; // Boolean | exclude bot users

            try {
                array[Object] result = apiInstance.getTeamUsers(teamID, search, excludeBots);
                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
            Boolean excludeBots = true; // Boolean | exclude bot users

            try {
                array[Object] result = apiInstance.getTeamUsers(teamID, search, excludeBots);
                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)
    Boolean *excludeBots = true; // exclude bot users (optional) (default to null)

    [apiInstance getTeamUsersWith:teamID
        search:search
        excludeBots:excludeBots
                  completionHandler: ^(array[Object] 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
      'excludeBots': true // {Boolean} exclude bot users
    };

    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)
                var excludeBots = true;  // Boolean | exclude bot users (optional)  (default to null)

                try {
                    array[Object] result = apiInstance.getTeamUsers(teamID, search, excludeBots);
                    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
    $excludeBots = true; // Boolean | exclude bot users

    try {
        $result = $api_instance->getTeamUsers($teamID, $search, $excludeBots);
        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
    my $excludeBots = true; # Boolean | exclude bot users

    eval {
        my $result = $api_instance->getTeamUsers(teamID => $teamID, search => $search, excludeBots => $excludeBots);
        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)
    excludeBots = true # Boolean | exclude bot users (optional) (default to null)

    try:
        api_response = api_instance.get_team_users(teamID, search=search, excludeBots=excludeBots)
        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 excludeBots = true; // Boolean

        let mut context = DefaultApi::Context::default();
        let result = client.getTeamUsers(teamID, search, excludeBots, &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
exclude_bots | Boolean exclude bot users

## 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[Object] 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[Object] 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[Object] 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[Object] 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[Object] 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[Object] 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[Object] 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[Object] 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 {
                Object 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 {
                Object 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: ^(Object 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 {
                    Object 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

###

###

# getUserBoardsInsights

Returns user boards insights

    /users/me/boards/insights

### Usage and SDK Samples

    curl -X GET \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/users/me/boards/insights?time_range=timeRange_example&page=page_example&per_page=perPage_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 timeRange = timeRange_example; // String | duration of data to calculate insights for
            String page = page_example; // String | page offset for top boards
            String perPage = perPage_example; // String | limit for boards in a page.

            try {
                array[Object] result = apiInstance.getUserBoardsInsights(teamID, timeRange, page, perPage);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getUserBoardsInsights");
                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 timeRange = timeRange_example; // String | duration of data to calculate insights for
            String page = page_example; // String | page offset for top boards
            String perPage = perPage_example; // String | limit for boards in a page.

            try {
                array[Object] result = apiInstance.getUserBoardsInsights(teamID, timeRange, page, perPage);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getUserBoardsInsights");
                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 *timeRange = timeRange_example; // duration of data to calculate insights for (default to null)
    String *page = page_example; // page offset for top boards (default to null)
    String *perPage = perPage_example; // limit for boards in a page. (default to null)

    [apiInstance getUserBoardsInsightsWith:teamID
        timeRange:timeRange
        page:page
        perPage:perPage
                  completionHandler: ^(array[Object] 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 timeRange = timeRange_example; // {String} duration of data to calculate insights for
    var page = page_example; // {String} page offset for top boards
    var perPage = perPage_example; // {String} limit for boards in a page.

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

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

    namespace Example
    {
        public class getUserBoardsInsightsExample
        {
            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 timeRange = timeRange_example;  // String | duration of data to calculate insights for (default to null)
                var page = page_example;  // String | page offset for top boards (default to null)
                var perPage = perPage_example;  // String | limit for boards in a page. (default to null)

                try {
                    array[Object] result = apiInstance.getUserBoardsInsights(teamID, timeRange, page, perPage);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getUserBoardsInsights: " + 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
    $timeRange = timeRange_example; // String | duration of data to calculate insights for
    $page = page_example; // String | page offset for top boards
    $perPage = perPage_example; // String | limit for boards in a page.

    try {
        $result = $api_instance->getUserBoardsInsights($teamID, $timeRange, $page, $perPage);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getUserBoardsInsights: ', $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 $timeRange = timeRange_example; # String | duration of data to calculate insights for
    my $page = page_example; # String | page offset for top boards
    my $perPage = perPage_example; # String | limit for boards in a page.

    eval {
        my $result = $api_instance->getUserBoardsInsights(teamID => $teamID, timeRange => $timeRange, page => $page, perPage => $perPage);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getUserBoardsInsights: $@\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)
    timeRange = timeRange_example # String | duration of data to calculate insights for (default to null)
    page = page_example # String | page offset for top boards (default to null)
    perPage = perPage_example # String | limit for boards in a page. (default to null)

    try:
        api_response = api_instance.get_user_boards_insights(teamID, timeRange, page, perPage)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getUserBoardsInsights: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let teamID = teamID_example; // String
        let timeRange = timeRange_example; // String
        let page = page_example; // String
        let perPage = perPage_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.getUserBoardsInsights(teamID, timeRange, page, perPage, &context).wait();

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

## Scopes

## Parameters

Path parameters

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

Query parameters

Name | Description
--- | ---
time_range* | String duration of data to calculate insights for Required
page* | String page offset for top boards Required
per_page* | String limit for boards in a page. 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[Object] 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[Object] 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[Object] 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[Object] 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

###

###

# getUserConfig

Returns an array of user preferences

    /users/me/config

### Usage and SDK Samples

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

    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 {
                Preferences result = apiInstance.getUserConfig();
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getUserConfig");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

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

            try {
                Preferences result = apiInstance.getUserConfig();
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getUserConfig");
                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 getUserConfigWithCompletionHandler:
                  ^(Preferences 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.getUserConfig(callback);

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

    namespace Example
    {
        public class getUserConfigExample
        {
            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 {
                    Preferences result = apiInstance.getUserConfig();
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getUserConfig: " + 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->getUserConfig();
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getUserConfig: ', $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->getUserConfig();
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getUserConfig: $@\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_user_config()
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getUserConfig: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {

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

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

## Scopes

## Parameters

## Responses

###

###

# getUsersList

Returns a user[]

    /users

### Usage and SDK Samples

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

    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 {
                Object result = apiInstance.getUsersList(userID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getUsersList");
                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 {
                Object result = apiInstance.getUsersList(userID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getUsersList");
                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 getUsersListWith:userID
                  completionHandler: ^(Object 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.getUsersList(userID, callback);

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

    namespace Example
    {
        public class getUsersListExample
        {
            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 {
                    Object result = apiInstance.getUsersList(userID);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getUsersList: " + 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->getUsersList($userID);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getUsersList: ', $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->getUsersList(userID => $userID);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getUsersList: $@\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_users_list(userID)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getUsersList: %s\n" % e)

    extern crate DefaultApi;

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

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

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

## Scopes

## Parameters

Path parameters

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

## Responses

###

###

# handleNotifyAdminUpgrade

Notifies admins for upgrade request.

    /api/v2/teams/{teamID}/notifyadminupgrade

### Usage and SDK Samples

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

    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.handleNotifyAdminUpgrade(teamID);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#handleNotifyAdminUpgrade");
                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.handleNotifyAdminUpgrade(teamID);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#handleNotifyAdminUpgrade");
                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)

    // Notifies admins for upgrade request.
    [apiInstance handleNotifyAdminUpgradeWith: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.handleNotifyAdminUpgrade(teamID, callback);

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

    namespace Example
    {
        public class handleNotifyAdminUpgradeExample
        {
            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 {
                    // Notifies admins for upgrade request.
                    apiInstance.handleNotifyAdminUpgrade(teamID);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.handleNotifyAdminUpgrade: " + 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->handleNotifyAdminUpgrade($teamID);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->handleNotifyAdminUpgrade: ', $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->handleNotifyAdminUpgrade(teamID => $teamID);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->handleNotifyAdminUpgrade: $@\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:
        # Notifies admins for upgrade request.
        api_instance.handle_notify_admin_upgrade(teamID)
    except ApiException as e:
        print("Exception when calling DefaultApi->handleNotifyAdminUpgrade: %s\n" % e)

    extern crate DefaultApi;

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

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

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

## Scopes

## Parameters

Path parameters

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

## Responses

###

###

# handleStatistics

Fetches the statistic of the server.

    /statistics

### Usage and SDK Samples

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

    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 {
                BoardStatistics result = apiInstance.handleStatistics();
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#handleStatistics");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

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

            try {
                BoardStatistics result = apiInstance.handleStatistics();
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#handleStatistics");
                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];

    // Fetches the statistic  of the server.
    [apiInstance handleStatisticsWithCompletionHandler:
                  ^(BoardStatistics 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.handleStatistics(callback);

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

    namespace Example
    {
        public class handleStatisticsExample
        {
            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 {
                    // Fetches the statistic  of the server.
                    BoardStatistics result = apiInstance.handleStatistics();
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.handleStatistics: " + 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->handleStatistics();
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->handleStatistics: ', $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->handleStatistics();
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->handleStatistics: $@\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:
        # Fetches the statistic  of the server.
        api_response = api_instance.handle_statistics()
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->handleStatistics: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {

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

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

## Scopes

## Parameters

## Responses

###

###

# handleTeamBoardsInsights

Returns team boards insights

    /teams/{teamID}/boards/insights

### Usage and SDK Samples

    curl -X GET \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/teams/{teamID}/boards/insights?time_range=timeRange_example&page=page_example&per_page=perPage_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 timeRange = timeRange_example; // String | duration of data to calculate insights for
            String page = page_example; // String | page offset for top boards
            String perPage = perPage_example; // String | limit for boards in a page.

            try {
                array[Object] result = apiInstance.handleTeamBoardsInsights(teamID, timeRange, page, perPage);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#handleTeamBoardsInsights");
                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 timeRange = timeRange_example; // String | duration of data to calculate insights for
            String page = page_example; // String | page offset for top boards
            String perPage = perPage_example; // String | limit for boards in a page.

            try {
                array[Object] result = apiInstance.handleTeamBoardsInsights(teamID, timeRange, page, perPage);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#handleTeamBoardsInsights");
                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 *timeRange = timeRange_example; // duration of data to calculate insights for (default to null)
    String *page = page_example; // page offset for top boards (default to null)
    String *perPage = perPage_example; // limit for boards in a page. (default to null)

    [apiInstance handleTeamBoardsInsightsWith:teamID
        timeRange:timeRange
        page:page
        perPage:perPage
                  completionHandler: ^(array[Object] 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 timeRange = timeRange_example; // {String} duration of data to calculate insights for
    var page = page_example; // {String} page offset for top boards
    var perPage = perPage_example; // {String} limit for boards in a page.

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

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

    namespace Example
    {
        public class handleTeamBoardsInsightsExample
        {
            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 timeRange = timeRange_example;  // String | duration of data to calculate insights for (default to null)
                var page = page_example;  // String | page offset for top boards (default to null)
                var perPage = perPage_example;  // String | limit for boards in a page. (default to null)

                try {
                    array[Object] result = apiInstance.handleTeamBoardsInsights(teamID, timeRange, page, perPage);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.handleTeamBoardsInsights: " + 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
    $timeRange = timeRange_example; // String | duration of data to calculate insights for
    $page = page_example; // String | page offset for top boards
    $perPage = perPage_example; // String | limit for boards in a page.

    try {
        $result = $api_instance->handleTeamBoardsInsights($teamID, $timeRange, $page, $perPage);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->handleTeamBoardsInsights: ', $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 $timeRange = timeRange_example; # String | duration of data to calculate insights for
    my $page = page_example; # String | page offset for top boards
    my $perPage = perPage_example; # String | limit for boards in a page.

    eval {
        my $result = $api_instance->handleTeamBoardsInsights(teamID => $teamID, timeRange => $timeRange, page => $page, perPage => $perPage);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->handleTeamBoardsInsights: $@\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)
    timeRange = timeRange_example # String | duration of data to calculate insights for (default to null)
    page = page_example # String | page offset for top boards (default to null)
    perPage = perPage_example # String | limit for boards in a page. (default to null)

    try:
        api_response = api_instance.handle_team_boards_insights(teamID, timeRange, page, perPage)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->handleTeamBoardsInsights: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let teamID = teamID_example; // String
        let timeRange = timeRange_example; // String
        let page = page_example; // String
        let perPage = perPage_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.handleTeamBoardsInsights(teamID, timeRange, page, perPage, &context).wait();

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

## Scopes

## Parameters

Path parameters

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

Query parameters

Name | Description
--- | ---
time_range* | String duration of data to calculate insights for Required
page* | String page offset for top boards Required
per_page* | String limit for boards in a page. Required

## Responses

###

###

# hello

Responds with `Hello` if the web service is running.

    /hello

### Usage and SDK Samples

    curl -X GET \
     "http://localhost/api/v2/hello"

    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 {
                apiInstance.hello();
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#hello");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

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

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

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

    // Responds with `Hello` if the web service is running.
    [apiInstance helloWithCompletionHandler:
                  ^(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 callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully.');
      }
    };
    api.hello(callback);

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

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

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

                try {
                    // Responds with `Hello` if the web service is running.
                    apiInstance.hello();
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.hello: " + e.Message );
                }
            }
        }
    }

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

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

    try {
        $api_instance->hello();
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->hello: ', $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 {
        $api_instance->hello();
    };
    if ($@) {
        warn "Exception when calling DefaultApi->hello: $@\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:
        # Responds with `Hello` if the web service is running.
        api_instance.hello()
    except ApiException as e:
        print("Exception when calling DefaultApi->hello: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {

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

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

## Scopes

## Parameters

## 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 ''

    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();
            Object body = Object; // Object |

            try {
                Object 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();
            Object body = Object; // Object |

            try {
                Object 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];
    Object *body = Object; //

    [apiInstance insertBoardsAndBlocksWith:body
                  completionHandler: ^(Object 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 = Object; // {Object}

    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 = Object;  // Object |

                try {
                    Object 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 = Object; // Object |

    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::Object->new(); # Object |

    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 = Object # Object |

    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 = Object; // Object

        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 {
                Object 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 {
                Object 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: ^(Object 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 {
                    Object 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 ''

    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();
            Object body = Object; // Object |

            try {
                Object 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();
            Object body = Object; // Object |

            try {
                Object 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];
    Object *body = Object; //

    [apiInstance loginWith:body
                  completionHandler: ^(Object 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 = Object; // {Object}

    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 = Object;  // Object |

                try {
                    Object 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 = Object; // Object |

    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::Object->new(); # Object |

    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 = Object # Object |

    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 = Object; // Object

        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 {
                onboard_200_response 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 {
                onboard_200_response 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: ^(onboard_200_response 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.
                    onboard_200_response 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}?disable_notify=" \
     -d ''

    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
            Object body = Object; // Object |
            oas_any_type_not_mapped disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk patching)

            try {
                apiInstance.patchBlock(boardID, blockID, body, disableNotify);
            } 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
            Object body = Object; // Object |
            oas_any_type_not_mapped disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk patching)

            try {
                apiInstance.patchBlock(boardID, blockID, body, disableNotify);
            } 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)
    Object *body = Object; //
    oas_any_type_not_mapped *disableNotify = ; // Disables notifications (for bulk patching) (optional) (default to null)

    [apiInstance patchBlockWith:boardID
        blockID:blockID
        body:body
        disableNotify:disableNotify
                  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 = Object; // {Object}
    var opts = {
      'disableNotify':  // {oas_any_type_not_mapped} Disables notifications (for bulk patching)
    };

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully.');
      }
    };
    api.patchBlock(boardID, blockID, body, opts, 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 = Object;  // Object |
                var disableNotify = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | Disables notifications (for bulk patching) (optional)  (default to null)

                try {
                    apiInstance.patchBlock(boardID, blockID, body, disableNotify);
                } 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 = Object; // Object |
    $disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk patching)

    try {
        $api_instance->patchBlock($boardID, $blockID, $body, $disableNotify);
    } 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::Object->new(); # Object |
    my $disableNotify = ; # oas_any_type_not_mapped | Disables notifications (for bulk patching)

    eval {
        $api_instance->patchBlock(boardID => $boardID, blockID => $blockID, body => $body, disableNotify => $disableNotify);
    };
    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 = Object # Object |
    disableNotify =  # oas_any_type_not_mapped | Disables notifications (for bulk patching) (optional) (default to null)

    try:
        api_instance.patch_block(boardID, blockID, body, disableNotify=disableNotify)
    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 = Object; // Object
        let disableNotify = ; // oas_any_type_not_mapped

        let mut context = DefaultApi::Context::default();
        let result = client.patchBlock(boardID, blockID, body, disableNotify, &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

Query parameters

Name | Description
--- | ---
disable_notify | oas_any_type_not_mapped Disables notifications (for bulk patching)

## 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/?disable_notify=" \
     -d ''

    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
            Object body = Object; // Object |
            oas_any_type_not_mapped disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk patching)

            try {
                apiInstance.patchBlocks(boardID, body, disableNotify);
            } 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
            Object body = Object; // Object |
            oas_any_type_not_mapped disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk patching)

            try {
                apiInstance.patchBlocks(boardID, body, disableNotify);
            } 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)
    Object *body = Object; //
    oas_any_type_not_mapped *disableNotify = ; // Disables notifications (for bulk patching) (optional) (default to null)

    [apiInstance patchBlocksWith:boardID
        body:body
        disableNotify:disableNotify
                  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 = Object; // {Object}
    var opts = {
      'disableNotify':  // {oas_any_type_not_mapped} Disables notifications (for bulk patching)
    };

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully.');
      }
    };
    api.patchBlocks(boardID, body, opts, 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 = Object;  // Object |
                var disableNotify = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | Disables notifications (for bulk patching) (optional)  (default to null)

                try {
                    apiInstance.patchBlocks(boardID, body, disableNotify);
                } 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 = Object; // Object |
    $disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk patching)

    try {
        $api_instance->patchBlocks($boardID, $body, $disableNotify);
    } 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::Object->new(); # Object |
    my $disableNotify = ; # oas_any_type_not_mapped | Disables notifications (for bulk patching)

    eval {
        $api_instance->patchBlocks(boardID => $boardID, body => $body, disableNotify => $disableNotify);
    };
    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 = Object # Object |
    disableNotify =  # oas_any_type_not_mapped | Disables notifications (for bulk patching) (optional) (default to null)

    try:
        api_instance.patch_blocks(boardID, body, disableNotify=disableNotify)
    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 = Object; // Object
        let disableNotify = ; // oas_any_type_not_mapped

        let mut context = DefaultApi::Context::default();
        let result = client.patchBlocks(boardID, body, disableNotify, &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

Query parameters

Name | Description
--- | ---
disable_notify | oas_any_type_not_mapped Disables notifications (for bulk patching)

## 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 ''

    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
            Object body = Object; // Object |

            try {
                Object 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
            Object body = Object; // Object |

            try {
                Object 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)
    Object *body = Object; //

    [apiInstance patchBoardWith:boardID
        body:body
                  completionHandler: ^(Object 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 = Object; // {Object}

    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 = Object;  // Object |

                try {
                    Object 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 = Object; // Object |

    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::Object->new(); # Object |

    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 = Object # Object |

    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 = Object; // Object

        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 ''

    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();
            Object body = Object; // Object |

            try {
                Object 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();
            Object body = Object; // Object |

            try {
                Object 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];
    Object *body = Object; //

    [apiInstance patchBoardsAndBlocksWith:body
                  completionHandler: ^(Object 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 = Object; // {Object}

    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 = Object;  // Object |

                try {
                    Object 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 = Object; // Object |

    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::Object->new(); # Object |

    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 = Object # Object |

    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 = Object; // Object

        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

###

###

# patchCard

Patches the specified card.

    /cards/{cardID}/cards

### Usage and SDK Samples

    curl -X PATCH \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "http://localhost/api/v2/cards/{cardID}/cards?disable_notify=" \
     -d ''

    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 cardID = cardID_example; // String | Card ID
            Object body = Object; // Object |
            oas_any_type_not_mapped disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk data patching)

            try {
                Object result = apiInstance.patchCard(cardID, body, disableNotify);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#patchCard");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String cardID = cardID_example; // String | Card ID
            Object body = Object; // Object |
            oas_any_type_not_mapped disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk data patching)

            try {
                Object result = apiInstance.patchCard(cardID, body, disableNotify);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#patchCard");
                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 *cardID = cardID_example; // Card ID (default to null)
    Object *body = Object; //
    oas_any_type_not_mapped *disableNotify = ; // Disables notifications (for bulk data patching) (optional) (default to null)

    // Patches the specified card.
    [apiInstance patchCardWith:cardID
        body:body
        disableNotify:disableNotify
                  completionHandler: ^(Object 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 cardID = cardID_example; // {String} Card ID
    var body = Object; // {Object}
    var opts = {
      'disableNotify':  // {oas_any_type_not_mapped} Disables notifications (for bulk data patching)
    };

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

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

    namespace Example
    {
        public class patchCardExample
        {
            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 cardID = cardID_example;  // String | Card ID (default to null)
                var body = Object;  // Object |
                var disableNotify = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | Disables notifications (for bulk data patching) (optional)  (default to null)

                try {
                    // Patches the specified card.
                    Object result = apiInstance.patchCard(cardID, body, disableNotify);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.patchCard: " + 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();
    $cardID = cardID_example; // String | Card ID
    $body = Object; // Object |
    $disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk data patching)

    try {
        $result = $api_instance->patchCard($cardID, $body, $disableNotify);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->patchCard: ', $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 $cardID = cardID_example; # String | Card ID
    my $body = WWW::OPenAPIClient::Object::Object->new(); # Object |
    my $disableNotify = ; # oas_any_type_not_mapped | Disables notifications (for bulk data patching)

    eval {
        my $result = $api_instance->patchCard(cardID => $cardID, body => $body, disableNotify => $disableNotify);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->patchCard: $@\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()
    cardID = cardID_example # String | Card ID (default to null)
    body = Object # Object |
    disableNotify =  # oas_any_type_not_mapped | Disables notifications (for bulk data patching) (optional) (default to null)

    try:
        # Patches the specified card.
        api_response = api_instance.patch_card(cardID, body, disableNotify=disableNotify)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->patchCard: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let cardID = cardID_example; // String
        let body = Object; // Object
        let disableNotify = ; // oas_any_type_not_mapped

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

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

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
cardID* | String Card ID Required

Body parameters

Name | Description
--- | ---
body * | the card patch

Query parameters

Name | Description
--- | ---
disable_notify | oas_any_type_not_mapped Disables notifications (for bulk data patching)

## Responses

###

###

# ping

Responds with server metadata if the web service is running.

    /ping

### Usage and SDK Samples

    curl -X GET \
     "http://localhost/api/v2/ping"

    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 {
                apiInstance.ping();
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#ping");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

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

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

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

    // Responds with server metadata if the web service is running.
    [apiInstance pingWithCompletionHandler:
                  ^(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 callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully.');
      }
    };
    api.ping(callback);

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

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

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

                try {
                    // Responds with server metadata if the web service is running.
                    apiInstance.ping();
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.ping: " + e.Message );
                }
            }
        }
    }

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

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

    try {
        $api_instance->ping();
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->ping: ', $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 {
        $api_instance->ping();
    };
    if ($@) {
        warn "Exception when calling DefaultApi->ping: $@\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:
        # Responds with server metadata if the web service is running.
        api_instance.ping()
    except ApiException as e:
        print("Exception when calling DefaultApi->ping: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {

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

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

## Scopes

## Parameters

## 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 ''

    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
            Object body = Object; // Object |

            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
            Object body = Object; // Object |

            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)
    Object *body = Object; //

    [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 = Object; // {Object}

    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 = Object;  // Object |

                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 = Object; // Object |

    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::Object->new(); # Object |

    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 = Object # Object |

    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 = Object; // Object

        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 ''

    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();
            Object body = Object; // Object |

            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();
            Object body = Object; // Object |

            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];
    Object *body = Object; //

    [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 = Object; // {Object}

    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 = Object;  // Object |

                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 = Object; // Object |

    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::Object->new(); # Object |

    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 = Object # Object |

    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 = Object; // Object

        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

###

###

###

# searchAllBoards

Returns the boards that match with a search term

    /boards/search

### Usage and SDK Samples

    curl -X GET \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/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 q = q_example; // String | The search term. Must have at least one character

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

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String q = q_example; // String | The search term. Must have at least one character

            try {
                array[Object] result = apiInstance.searchAllBoards(q);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#searchAllBoards");
                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 *q = q_example; // The search term. Must have at least one character (default to null)

    [apiInstance searchAllBoardsWith:q
                  completionHandler: ^(array[Object] 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 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.searchAllBoards(q, callback);

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

    namespace Example
    {
        public class searchAllBoardsExample
        {
            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 q = q_example;  // String | The search term. Must have at least one character (default to null)

                try {
                    array[Object] result = apiInstance.searchAllBoards(q);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.searchAllBoards: " + 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();
    $q = q_example; // String | The search term. Must have at least one character

    try {
        $result = $api_instance->searchAllBoards($q);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->searchAllBoards: ', $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 $q = q_example; # String | The search term. Must have at least one character

    eval {
        my $result = $api_instance->searchAllBoards(q => $q);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->searchAllBoards: $@\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()
    q = q_example # String | The search term. Must have at least one character (default to null)

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

    extern crate DefaultApi;

    pub fn main() {
        let q = q_example; // String

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

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

## Scopes

## Parameters

Query parameters

Name | Description
--- | ---
q* | String The search term. Must have at least one character Required

## Responses

###

###

# searchBoards

Returns the boards that match with a search term in the team

    /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[Object] 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[Object] 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[Object] 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[Object] 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

###

###

# searchLinkableBoards

Returns the boards that match with a search term in the team and the user has permission to manage members

    /teams/{teamID}/boards/search/linkable

### Usage and SDK Samples

    curl -X GET \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/teams/{teamID}/boards/search/linkable?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[Object] result = apiInstance.searchLinkableBoards(teamID, q);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#searchLinkableBoards");
                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[Object] result = apiInstance.searchLinkableBoards(teamID, q);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#searchLinkableBoards");
                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 searchLinkableBoardsWith:teamID
        q:q
                  completionHandler: ^(array[Object] 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.searchLinkableBoards(teamID, q, callback);

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

    namespace Example
    {
        public class searchLinkableBoardsExample
        {
            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[Object] result = apiInstance.searchLinkableBoards(teamID, q);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.searchLinkableBoards: " + 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->searchLinkableBoards($teamID, $q);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->searchLinkableBoards: ', $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->searchLinkableBoards(teamID => $teamID, q => $q);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->searchLinkableBoards: $@\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_linkable_boards(teamID, q)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->searchLinkableBoards: %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.searchLinkableBoards(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

###

###

# searchMyChannels

Returns the user available channels

    /teams/{teamID}/channels

### Usage and SDK Samples

    curl -X GET \
    -H "Authorization: [[apiKey]]" \
     -H "Accept: application/json" \
     "http://localhost/api/v2/teams/{teamID}/channels?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 channels list

            try {
                array[Channel] result = apiInstance.searchMyChannels(teamID, search);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#searchMyChannels");
                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 channels list

            try {
                array[Channel] result = apiInstance.searchMyChannels(teamID, search);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#searchMyChannels");
                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 channels list (optional) (default to null)

    [apiInstance searchMyChannelsWith:teamID
        search:search
                  completionHandler: ^(array[Channel] 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 channels list
    };

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

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

    namespace Example
    {
        public class searchMyChannelsExample
        {
            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 channels list (optional)  (default to null)

                try {
                    array[Channel] result = apiInstance.searchMyChannels(teamID, search);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.searchMyChannels: " + 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 channels list

    try {
        $result = $api_instance->searchMyChannels($teamID, $search);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->searchMyChannels: ', $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 channels list

    eval {
        my $result = $api_instance->searchMyChannels(teamID => $teamID, search => $search);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->searchMyChannels: $@\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 channels list (optional) (default to null)

    try:
        api_response = api_instance.search_my_channels(teamID, search=search)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->searchMyChannels: %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.searchMyChannels(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 channels list

## 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 {
                Object 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 {
                Object 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: ^(Object 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 {
                    Object 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?disable_notify=" \
     -d ''

    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[Object] body = ; // array[Object] |
            oas_any_type_not_mapped disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk inserting)

            try {
                array[Object] result = apiInstance.updateBlocks(boardID, body, disableNotify);
                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[Object] body = ; // array[Object] |
            oas_any_type_not_mapped disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk inserting)

            try {
                array[Object] result = apiInstance.updateBlocks(boardID, body, disableNotify);
                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[Object] *body = ; //
    oas_any_type_not_mapped *disableNotify = ; // Disables notifications (for bulk inserting) (optional) (default to null)

    [apiInstance updateBlocksWith:boardID
        body:body
        disableNotify:disableNotify
                  completionHandler: ^(array[Object] 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[Object]}
    var opts = {
      'disableNotify':  // {oas_any_type_not_mapped} Disables notifications (for bulk inserting)
    };

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.updateBlocks(boardID, body, opts, 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[Object](); // array[Object] |
                var disableNotify = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | Disables notifications (for bulk inserting) (optional)  (default to null)

                try {
                    array[Object] result = apiInstance.updateBlocks(boardID, body, disableNotify);
                    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[Object] |
    $disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk inserting)

    try {
        $result = $api_instance->updateBlocks($boardID, $body, $disableNotify);
        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[Object]->new()]; # array[Object] |
    my $disableNotify = ; # oas_any_type_not_mapped | Disables notifications (for bulk inserting)

    eval {
        my $result = $api_instance->updateBlocks(boardID => $boardID, body => $body, disableNotify => $disableNotify);
        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[Object] |
    disableNotify =  # oas_any_type_not_mapped | Disables notifications (for bulk inserting) (optional) (default to null)

    try:
        api_response = api_instance.update_blocks(boardID, body, disableNotify=disableNotify)
        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[Object]
        let disableNotify = ; // oas_any_type_not_mapped

        let mut context = DefaultApi::Context::default();
        let result = client.updateBlocks(boardID, body, disableNotify, &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

Query parameters

Name | Description
--- | ---
disable_notify | oas_any_type_not_mapped Disables notifications (for bulk inserting)

## 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 ''

    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
            Object body = Object; // Object |

            try {
                Object 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
            Object body = Object; // Object |

            try {
                Object 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)
    Object *body = Object; //

    [apiInstance updateCategoryWith:teamID
        categoryID:categoryID
        body:body
                  completionHandler: ^(Object 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 = Object; // {Object}

    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 = Object;  // Object |

                try {
                    Object 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 = Object; // Object |

    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::Object->new(); # Object |

    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 = Object # Object |

    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 = Object; // Object

        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 ''

    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
            Object body = Object; // Object |

            try {
                Object 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
            Object body = Object; // Object |

            try {
                Object 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)
    Object *body = Object; //

    [apiInstance updateMemberWith:boardID
        userID:userID
        body:body
                  completionHandler: ^(Object 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 = Object; // {Object}

    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 = Object;  // Object |

                try {
                    Object 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 = Object; // Object |

    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::Object->new(); # Object |

    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 = Object # Object |

    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 = Object; // Object

        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 ''

    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
            Object body = Object; // Object |

            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
            Object body = Object; // Object |

            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)
    Object *body = Object; //

    [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 = Object; // {Object}

    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 = Object;  // Object |

                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 = Object; // Object |

    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::Object->new(); # Object |

    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 = Object # Object |

    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 = Object; // Object

        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 {
                Object 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 {
                Object 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: ^(Object 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 {
                    Object 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

###

###

###