# Focalboard Server

# Focalboard Server Package classification Focalboard Server

## API and SDK Documentation

Version: 1.0.0

Server for Focalboard

# Default

# changePassword

Change a user's password

    /api/v1/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/v1/api/v1/users/{userID}/changepassword"

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

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

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

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

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

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

    import org.openapitools.client.api.DefaultApi;

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

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

    Configuration *apiConfig = [Configuration sharedConfig];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    extern crate DefaultApi;

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

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

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

## Scopes

## Parameters

Path parameters

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

Body parameters

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

## Responses

###

###

###

# deleteBlock

Deletes a block

    /api/v1/workspaces/{workspaceID}/blocks/{blockID}

### Usage and SDK Samples

    curl -X DELETE\
    -H "Authorization: [[apiKey]]"\
     -H "Accept: application/json"\
     "http://localhost/api/v1/api/v1/workspaces/{workspaceID}/blocks/{blockID}"

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

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

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

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

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String workspaceID = workspaceID_example; // String | Workspace ID
            String blockID = blockID_example; // String | ID of block to delete

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

    import org.openapitools.client.api.DefaultApi;

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

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

    Configuration *apiConfig = [Configuration sharedConfig];

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

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

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

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

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

    // Create an instance of the API class
    var api = new focalboardServer.DefaultApi()
    var workspaceID = workspaceID_example; // {String} Workspace ID
    var blockID = blockID_example; // {String} ID of block to delete

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    extern crate DefaultApi;

    pub fn main() {
        let workspaceID = workspaceID_example; // String
        let blockID = blockID_example; // String

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

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

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
workspaceID* | String Workspace ID Required
blockID* | String ID of block to delete Required

## Responses

###

###

# exportBlocks

Returns all blocks

    /api/v1/workspaces/{workspaceID}/blocks/export

### Usage and SDK Samples

    curl -X GET\
    -H "Authorization: [[apiKey]]"\
     -H "Accept: application/json"\
     "http://localhost/api/v1/api/v1/workspaces/{workspaceID}/blocks/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 workspaceID = workspaceID_example; // String | Workspace ID

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

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String workspaceID = workspaceID_example; // String | Workspace ID

            try {
                array[Block] result = apiInstance.exportBlocks(workspaceID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#exportBlocks");
                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 *workspaceID = workspaceID_example; // Workspace ID (default to null)

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

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

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

    // Create an instance of the API class
    var api = new focalboardServer.DefaultApi()
    var workspaceID = workspaceID_example; // {String} Workspace ID

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

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

    namespace Example
    {
        public class exportBlocksExample
        {
            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 workspaceID = workspaceID_example;  // String | Workspace ID (default to null)

                try {
                    array[Block] result = apiInstance.exportBlocks(workspaceID);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.exportBlocks: " + 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();
    $workspaceID = workspaceID_example; // String | Workspace ID

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

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

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

    extern crate DefaultApi;

    pub fn main() {
        let workspaceID = workspaceID_example; // String

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

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

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
workspaceID* | String Workspace ID Required

## Responses

###

###

# getBlocks

Returns blocks

    /api/v1/workspaces/{workspaceID}/blocks

### Usage and SDK Samples

    curl -X GET\
    -H "Authorization: [[apiKey]]"\
     -H "Accept: application/json"\
     "http://localhost/api/v1/api/v1/workspaces/{workspaceID}/blocks?parent_id=&type="

    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 workspaceID = workspaceID_example; // String | Workspace ID
            String parentId = parentId_example; // String | ID of parent block, omit to specify all blocks
            String type = type_example; // String | Type of blocks to return, omit to specify all types

            try {
                array[Block] result = apiInstance.getBlocks(workspaceID, 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 workspaceID = workspaceID_example; // String | Workspace ID
            String parentId = parentId_example; // String | ID of parent block, omit to specify all blocks
            String type = type_example; // String | Type of blocks to return, omit to specify all types

            try {
                array[Block] result = apiInstance.getBlocks(workspaceID, 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 *workspaceID = workspaceID_example; // Workspace 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:workspaceID
        parentId:parentId
        type:type
                  completionHandler: ^(array[Block] output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

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

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

    // Create an instance of the API class
    var api = new focalboardServer.DefaultApi()
    var workspaceID = workspaceID_example; // {String} Workspace 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(workspaceID, 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 workspaceID = workspaceID_example;  // String | Workspace ID (default to null)
                var parentId = parentId_example;  // String | ID of parent block, omit to specify all blocks (optional)  (default to null)
                var type = type_example;  // String | Type of blocks to return, omit to specify all types (optional)  (default to null)

                try {
                    array[Block] result = apiInstance.getBlocks(workspaceID, 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();
    $workspaceID = workspaceID_example; // String | Workspace 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($workspaceID, $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 $workspaceID = workspaceID_example; # String | Workspace 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(workspaceID => $workspaceID, 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()
    workspaceID = workspaceID_example # String | Workspace 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(workspaceID, 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 workspaceID = workspaceID_example; // String
        let parentId = parentId_example; // String
        let type = type_example; // String

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

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

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
workspaceID* | String Workspace 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

###

###

# getFile

Returns the contents of an uploaded file

    /workspaces/{workspaceID}/{rootID}/{fileID}

### Usage and SDK Samples

    curl -X GET\
    -H "Authorization: [[apiKey]]"\
     -H "Accept: application/json,image/jpg,image/png"\
     "http://localhost/api/v1/workspaces/{workspaceID}/{rootID}/{fileID}"

    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 workspaceID = workspaceID_example; // String | Workspace ID
            String rootID = rootID_example; // String | ID of the root block
            String fileID = fileID_example; // String | ID of the file

            try {
                apiInstance.getFile(workspaceID, rootID, fileID);
            } 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 workspaceID = workspaceID_example; // String | Workspace ID
            String rootID = rootID_example; // String | ID of the root block
            String fileID = fileID_example; // String | ID of the file

            try {
                apiInstance.getFile(workspaceID, rootID, fileID);
            } 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 *workspaceID = workspaceID_example; // Workspace ID (default to null)
    String *rootID = rootID_example; // ID of the root block (default to null)
    String *fileID = fileID_example; // ID of the file (default to null)

    [apiInstance getFileWith:workspaceID
        rootID:rootID
        fileID:fileID
                  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 workspaceID = workspaceID_example; // {String} Workspace ID
    var rootID = rootID_example; // {String} ID of the root block
    var fileID = fileID_example; // {String} ID of the file

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully.');
      }
    };
    api.getFile(workspaceID, rootID, fileID, 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 workspaceID = workspaceID_example;  // String | Workspace ID (default to null)
                var rootID = rootID_example;  // String | ID of the root block (default to null)
                var fileID = fileID_example;  // String | ID of the file (default to null)

                try {
                    apiInstance.getFile(workspaceID, rootID, fileID);
                } 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();
    $workspaceID = workspaceID_example; // String | Workspace ID
    $rootID = rootID_example; // String | ID of the root block
    $fileID = fileID_example; // String | ID of the file

    try {
        $api_instance->getFile($workspaceID, $rootID, $fileID);
    } 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 $workspaceID = workspaceID_example; # String | Workspace ID
    my $rootID = rootID_example; # String | ID of the root block
    my $fileID = fileID_example; # String | ID of the file

    eval {
        $api_instance->getFile(workspaceID => $workspaceID, rootID => $rootID, fileID => $fileID);
    };
    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()
    workspaceID = workspaceID_example # String | Workspace ID (default to null)
    rootID = rootID_example # String | ID of the root block (default to null)
    fileID = fileID_example # String | ID of the file (default to null)

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

    extern crate DefaultApi;

    pub fn main() {
        let workspaceID = workspaceID_example; // String
        let rootID = rootID_example; // String
        let fileID = fileID_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.getFile(workspaceID, rootID, fileID, &context).wait();

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

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
workspaceID* | String Workspace ID Required
rootID* | String ID of the root block Required
fileID* | String ID of the file Required

## Responses

###

###

# getMe

Returns the currently logged-in user

    /api/v1/users/me

### Usage and SDK Samples

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

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

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

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

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

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

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

    import org.openapitools.client.api.DefaultApi;

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

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

    Configuration *apiConfig = [Configuration sharedConfig];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    extern crate DefaultApi;

    pub fn main() {

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

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

## Scopes

## Parameters

## Responses

###

###

# getSharing

Returns sharing information for a root block

    /api/v1/workspaces/{workspaceID}/sharing/{rootID}

### Usage and SDK Samples

    curl -X GET\
    -H "Authorization: [[apiKey]]"\
     -H "Accept: application/json"\
     "http://localhost/api/v1/api/v1/workspaces/{workspaceID}/sharing/{rootID}"

    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 workspaceID = workspaceID_example; // String | Workspace ID
            String rootID = rootID_example; // String | ID of the root block

            try {
                Sharing result = apiInstance.getSharing(workspaceID, rootID);
                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 workspaceID = workspaceID_example; // String | Workspace ID
            String rootID = rootID_example; // String | ID of the root block

            try {
                Sharing result = apiInstance.getSharing(workspaceID, rootID);
                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 *workspaceID = workspaceID_example; // Workspace ID (default to null)
    String *rootID = rootID_example; // ID of the root block (default to null)

    [apiInstance getSharingWith:workspaceID
        rootID:rootID
                  completionHandler: ^(Sharing output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

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

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

    // Create an instance of the API class
    var api = new focalboardServer.DefaultApi()
    var workspaceID = workspaceID_example; // {String} Workspace ID
    var rootID = rootID_example; // {String} ID of the root block

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.getSharing(workspaceID, rootID, 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 workspaceID = workspaceID_example;  // String | Workspace ID (default to null)
                var rootID = rootID_example;  // String | ID of the root block (default to null)

                try {
                    Sharing result = apiInstance.getSharing(workspaceID, rootID);
                    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();
    $workspaceID = workspaceID_example; // String | Workspace ID
    $rootID = rootID_example; // String | ID of the root block

    try {
        $result = $api_instance->getSharing($workspaceID, $rootID);
        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 $workspaceID = workspaceID_example; # String | Workspace ID
    my $rootID = rootID_example; # String | ID of the root block

    eval {
        my $result = $api_instance->getSharing(workspaceID => $workspaceID, rootID => $rootID);
        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()
    workspaceID = workspaceID_example # String | Workspace ID (default to null)
    rootID = rootID_example # String | ID of the root block (default to null)

    try:
        api_response = api_instance.get_sharing(workspaceID, rootID)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getSharing: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let workspaceID = workspaceID_example; // String
        let rootID = rootID_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.getSharing(workspaceID, rootID, &context).wait();

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

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
workspaceID* | String Workspace ID Required
rootID* | String ID of the root block Required

## Responses

###

###

# getSubTree

Returns the blocks of a subtree

    /api/v1/workspaces/{workspaceID}/blocks/{blockID}/subtree

### Usage and SDK Samples

    curl -X GET\
    -H "Authorization: [[apiKey]]"\
     -H "Accept: application/json"\
     "http://localhost/api/v1/api/v1/workspaces/{workspaceID}/blocks/{blockID}/subtree?l="

    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 workspaceID = workspaceID_example; // String | Workspace ID
            String blockID = blockID_example; // String | The ID of the root block of the subtree
            Integer l = 56; // Integer | The number of levels to return. 2 or 3. Defaults to 2.

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

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String workspaceID = workspaceID_example; // String | Workspace ID
            String blockID = blockID_example; // String | The ID of the root block of the subtree
            Integer l = 56; // Integer | The number of levels to return. 2 or 3. Defaults to 2.

            try {
                array[Block] result = apiInstance.getSubTree(workspaceID, blockID, l);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getSubTree");
                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 *workspaceID = workspaceID_example; // Workspace ID (default to null)
    String *blockID = blockID_example; // The ID of the root block of the subtree (default to null)
    Integer *l = 56; // The number of levels to return. 2 or 3. Defaults to 2. (optional) (default to null)

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

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

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

    // Create an instance of the API class
    var api = new focalboardServer.DefaultApi()
    var workspaceID = workspaceID_example; // {String} Workspace ID
    var blockID = blockID_example; // {String} The ID of the root block of the subtree
    var opts = {
      'l': 56 // {Integer} The number of levels to return. 2 or 3. Defaults to 2.
    };

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

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

    namespace Example
    {
        public class getSubTreeExample
        {
            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 workspaceID = workspaceID_example;  // String | Workspace ID (default to null)
                var blockID = blockID_example;  // String | The ID of the root block of the subtree (default to null)
                var l = 56;  // Integer | The number of levels to return. 2 or 3. Defaults to 2. (optional)  (default to null)

                try {
                    array[Block] result = apiInstance.getSubTree(workspaceID, blockID, l);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getSubTree: " + 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();
    $workspaceID = workspaceID_example; // String | Workspace ID
    $blockID = blockID_example; // String | The ID of the root block of the subtree
    $l = 56; // Integer | The number of levels to return. 2 or 3. Defaults to 2.

    try {
        $result = $api_instance->getSubTree($workspaceID, $blockID, $l);
        print_r($result);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->getSubTree: ', $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 $workspaceID = workspaceID_example; # String | Workspace ID
    my $blockID = blockID_example; # String | The ID of the root block of the subtree
    my $l = 56; # Integer | The number of levels to return. 2 or 3. Defaults to 2.

    eval {
        my $result = $api_instance->getSubTree(workspaceID => $workspaceID, blockID => $blockID, l => $l);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getSubTree: $@\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()
    workspaceID = workspaceID_example # String | Workspace ID (default to null)
    blockID = blockID_example # String | The ID of the root block of the subtree (default to null)
    l = 56 # Integer | The number of levels to return. 2 or 3. Defaults to 2. (optional) (default to null)

    try:
        api_response = api_instance.get_sub_tree(workspaceID, blockID, l=l)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getSubTree: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let workspaceID = workspaceID_example; // String
        let blockID = blockID_example; // String
        let l = 56; // Integer

        let mut context = DefaultApi::Context::default();
        let result = client.getSubTree(workspaceID, blockID, l, &context).wait();

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

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
workspaceID* | String Workspace ID Required
blockID* | String The ID of the root block of the subtree Required

Query parameters

Name | Description
--- | ---
l | Integer The number of levels to return. 2 or 3. Defaults to 2.

## Responses

###

###

# getUser

Returns a user

    /api/v1/users/{userID}

### Usage and SDK Samples

    curl -X GET\
    -H "Authorization: [[apiKey]]"\
     -H "Accept: application/json"\
     "http://localhost/api/v1/api/v1/users/{userID}"

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

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

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

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

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

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

    import org.openapitools.client.api.DefaultApi;

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

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

    Configuration *apiConfig = [Configuration sharedConfig];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    extern crate DefaultApi;

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

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

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

## Scopes

## Parameters

Path parameters

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

## Responses

###

###

# getWorkspace

Returns information of the root workspace

    /api/v1/workspaces/{workspaceID}

### Usage and SDK Samples

    curl -X GET\
    -H "Authorization: [[apiKey]]"\
     -H "Accept: application/json"\
     "http://localhost/api/v1/api/v1/workspaces/{workspaceID}"

    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 workspaceID = workspaceID_example; // String | Workspace ID

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

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String workspaceID = workspaceID_example; // String | Workspace ID

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

    [apiInstance getWorkspaceWith:workspaceID
                  completionHandler: ^(Workspace 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 workspaceID = workspaceID_example; // {String} Workspace ID

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

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

    namespace Example
    {
        public class getWorkspaceExample
        {
            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 workspaceID = workspaceID_example;  // String | Workspace ID (default to null)

                try {
                    Workspace result = apiInstance.getWorkspace(workspaceID);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getWorkspace: " + 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();
    $workspaceID = workspaceID_example; // String | Workspace ID

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

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

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

    extern crate DefaultApi;

    pub fn main() {
        let workspaceID = workspaceID_example; // String

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

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

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
workspaceID* | String Workspace ID Required

## Responses

###

###

# getWorkspaceUsers

Returns workspace users

    /api/v1/workspaces/{workspaceID}/users

### Usage and SDK Samples

    curl -X GET\
    -H "Authorization: [[apiKey]]"\
     -H "Accept: application/json"\
     "http://localhost/api/v1/api/v1/workspaces/{workspaceID}/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 workspaceID = workspaceID_example; // String | Workspace ID

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

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String workspaceID = workspaceID_example; // String | Workspace ID

            try {
                array[User] result = apiInstance.getWorkspaceUsers(workspaceID);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getWorkspaceUsers");
                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 *workspaceID = workspaceID_example; // Workspace ID (default to null)

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

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

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

    // Create an instance of the API class
    var api = new focalboardServer.DefaultApi()
    var workspaceID = workspaceID_example; // {String} Workspace ID

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

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

    namespace Example
    {
        public class getWorkspaceUsersExample
        {
            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 workspaceID = workspaceID_example;  // String | Workspace ID (default to null)

                try {
                    array[User] result = apiInstance.getWorkspaceUsers(workspaceID);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getWorkspaceUsers: " + 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();
    $workspaceID = workspaceID_example; // String | Workspace ID

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

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

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

    extern crate DefaultApi;

    pub fn main() {
        let workspaceID = workspaceID_example; // String

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

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

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
workspaceID* | String Workspace ID Required

## Responses

###

###

# importBlocks

Import blocks

    /api/v1/workspaces/{workspaceID}/blocks/import

### Usage and SDK Samples

    curl -X POST\
    -H "Authorization: [[apiKey]]"\
     -H "Accept: application/json"\
     -H "Content-Type: application/json"\
     "http://localhost/api/v1/api/v1/workspaces/{workspaceID}/blocks/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 workspaceID = workspaceID_example; // String | Workspace ID
            array[Block] body = ; // array[Block] |

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

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String workspaceID = workspaceID_example; // String | Workspace ID
            array[Block] body = ; // array[Block] |

            try {
                apiInstance.importBlocks(workspaceID, body);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#importBlocks");
                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 *workspaceID = workspaceID_example; // Workspace ID (default to null)
    array[Block] *body = ; //

    [apiInstance importBlocksWith:workspaceID
        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 workspaceID = workspaceID_example; // {String} Workspace ID
    var body = ; // {array[Block]}

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

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

    namespace Example
    {
        public class importBlocksExample
        {
            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 workspaceID = workspaceID_example;  // String | Workspace ID (default to null)
                var body = new array[Block](); // array[Block] |

                try {
                    apiInstance.importBlocks(workspaceID, body);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.importBlocks: " + 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();
    $workspaceID = workspaceID_example; // String | Workspace ID
    $body = ; // array[Block] |

    try {
        $api_instance->importBlocks($workspaceID, $body);
    } catch (Exception $e) {
        echo 'Exception when calling DefaultApi->importBlocks: ', $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 $workspaceID = workspaceID_example; # String | Workspace ID
    my $body = [WWW::OPenAPIClient::Object::array[Block]->new()]; # array[Block] |

    eval {
        $api_instance->importBlocks(workspaceID => $workspaceID, body => $body);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->importBlocks: $@\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()
    workspaceID = workspaceID_example # String | Workspace ID (default to null)
    body =  # array[Block] |

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

    extern crate DefaultApi;

    pub fn main() {
        let workspaceID = workspaceID_example; // String
        let body = ; // array[Block]

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

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

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
workspaceID* | String Workspace ID Required

Body parameters

Name | Description
--- | ---
body * | array of blocks to import

## Responses

###

###

# login

Login user

    /api/v1/login

### Usage and SDK Samples

    curl -X POST\
     -H "Accept: application/json"\
     -H "Content-Type: application/json"\
     "http://localhost/api/v1/api/v1/login"

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

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

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

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

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

    import org.openapitools.client.api.DefaultApi;

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

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

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

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

    var focalboardServer = require('focalboard_server');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    extern crate DefaultApi;

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

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

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

## Scopes

## Parameters

Body parameters

Name | Description
--- | ---
body * | Login request

## Responses

###

###

###

# postSharing

Sets sharing information for a root block

    /api/v1/workspaces/{workspaceID}/sharing/{rootID}

### Usage and SDK Samples

    curl -X POST\
    -H "Authorization: [[apiKey]]"\
     -H "Accept: application/json"\
     -H "Content-Type: application/json"\
     "http://localhost/api/v1/api/v1/workspaces/{workspaceID}/sharing/{rootID}"

    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 workspaceID = workspaceID_example; // String | Workspace ID
            String rootID = rootID_example; // String | ID of the root block
            Sharing body = ; // Sharing |

            try {
                apiInstance.postSharing(workspaceID, rootID, 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 workspaceID = workspaceID_example; // String | Workspace ID
            String rootID = rootID_example; // String | ID of the root block
            Sharing body = ; // Sharing |

            try {
                apiInstance.postSharing(workspaceID, rootID, 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 *workspaceID = workspaceID_example; // Workspace ID (default to null)
    String *rootID = rootID_example; // ID of the root block (default to null)
    Sharing *body = ; //

    [apiInstance postSharingWith:workspaceID
        rootID:rootID
        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 workspaceID = workspaceID_example; // {String} Workspace ID
    var rootID = rootID_example; // {String} ID of the root block
    var body = ; // {Sharing}

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully.');
      }
    };
    api.postSharing(workspaceID, rootID, 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 workspaceID = workspaceID_example;  // String | Workspace ID (default to null)
                var rootID = rootID_example;  // String | ID of the root block (default to null)
                var body = new Sharing(); // Sharing |

                try {
                    apiInstance.postSharing(workspaceID, rootID, 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();
    $workspaceID = workspaceID_example; // String | Workspace ID
    $rootID = rootID_example; // String | ID of the root block
    $body = ; // Sharing |

    try {
        $api_instance->postSharing($workspaceID, $rootID, $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 $workspaceID = workspaceID_example; # String | Workspace ID
    my $rootID = rootID_example; # String | ID of the root block
    my $body = WWW::OPenAPIClient::Object::Sharing->new(); # Sharing |

    eval {
        $api_instance->postSharing(workspaceID => $workspaceID, rootID => $rootID, 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()
    workspaceID = workspaceID_example # String | Workspace ID (default to null)
    rootID = rootID_example # String | ID of the root block (default to null)
    body =  # Sharing |

    try:
        api_instance.post_sharing(workspaceID, rootID, body)
    except ApiException as e:
        print("Exception when calling DefaultApi->postSharing: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let workspaceID = workspaceID_example; // String
        let rootID = rootID_example; // String
        let body = ; // Sharing

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

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

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
workspaceID* | String Workspace ID Required
rootID* | String ID of the root block Required

Body parameters

Name | Description
--- | ---
body * | sharing information for a root block

## Responses

###

###

# regenerateSignupToken

Regenerates the signup token for the root workspace

    /api/v1/workspaces/{workspaceID}/regenerate_signup_token

### Usage and SDK Samples

    curl -X POST\
    -H "Authorization: [[apiKey]]"\
     -H "Accept: application/json"\
     "http://localhost/api/v1/api/v1/workspaces/{workspaceID}/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 workspaceID = workspaceID_example; // String | Workspace ID

            try {
                apiInstance.regenerateSignupToken(workspaceID);
            } 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 workspaceID = workspaceID_example; // String | Workspace ID

            try {
                apiInstance.regenerateSignupToken(workspaceID);
            } 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 *workspaceID = workspaceID_example; // Workspace ID (default to null)

    [apiInstance regenerateSignupTokenWith:workspaceID
                  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 workspaceID = workspaceID_example; // {String} Workspace ID

    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully.');
      }
    };
    api.regenerateSignupToken(workspaceID, 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 workspaceID = workspaceID_example;  // String | Workspace ID (default to null)

                try {
                    apiInstance.regenerateSignupToken(workspaceID);
                } 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();
    $workspaceID = workspaceID_example; // String | Workspace ID

    try {
        $api_instance->regenerateSignupToken($workspaceID);
    } 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 $workspaceID = workspaceID_example; # String | Workspace ID

    eval {
        $api_instance->regenerateSignupToken(workspaceID => $workspaceID);
    };
    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()
    workspaceID = workspaceID_example # String | Workspace ID (default to null)

    try:
        api_instance.regenerate_signup_token(workspaceID)
    except ApiException as e:
        print("Exception when calling DefaultApi->regenerateSignupToken: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let workspaceID = workspaceID_example; // String

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

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

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
workspaceID* | String Workspace ID Required

## Responses

###

###

# register

Register new user

    /api/v1/register

### Usage and SDK Samples

    curl -X POST\
     -H "Accept: application/json"\
     -H "Content-Type: application/json"\
     "http://localhost/api/v1/api/v1/register"

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

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

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

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

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

    import org.openapitools.client.api.DefaultApi;

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

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

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

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

    var focalboardServer = require('focalboard_server');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    extern crate DefaultApi;

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

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

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

## Scopes

## Parameters

Body parameters

Name | Description
--- | ---
body * | Register request

## Responses

###

###

###

# updateBlocks

Insert or update blocks

    /api/v1/workspaces/{workspaceID}/blocks

### Usage and SDK Samples

    curl -X POST\
    -H "Authorization: [[apiKey]]"\
     -H "Accept: application/json"\
     -H "Content-Type: application/json"\
     "http://localhost/api/v1/api/v1/workspaces/{workspaceID}/blocks"

    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 workspaceID = workspaceID_example; // String | Workspace ID
            array[Block] body = ; // array[Block] |

            try {
                apiInstance.updateBlocks(workspaceID, body);
            } 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 workspaceID = workspaceID_example; // String | Workspace ID
            array[Block] body = ; // array[Block] |

            try {
                apiInstance.updateBlocks(workspaceID, body);
            } 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 *workspaceID = workspaceID_example; // Workspace ID (default to null)
    array[Block] *body = ; //

    [apiInstance updateBlocksWith:workspaceID
        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 workspaceID = workspaceID_example; // {String} Workspace ID
    var body = ; // {array[Block]}

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

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

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

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var workspaceID = workspaceID_example;  // String | Workspace ID (default to null)
                var body = new array[Block](); // array[Block] |

                try {
                    apiInstance.updateBlocks(workspaceID, body);
                } 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();
    $workspaceID = workspaceID_example; // String | Workspace ID
    $body = ; // array[Block] |

    try {
        $api_instance->updateBlocks($workspaceID, $body);
    } 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 $workspaceID = workspaceID_example; # String | Workspace ID
    my $body = [WWW::OPenAPIClient::Object::array[Block]->new()]; # array[Block] |

    eval {
        $api_instance->updateBlocks(workspaceID => $workspaceID, body => $body);
    };
    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()
    workspaceID = workspaceID_example # String | Workspace ID (default to null)
    body =  # array[Block] |

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

    extern crate DefaultApi;

    pub fn main() {
        let workspaceID = workspaceID_example; // String
        let body = ; // array[Block]

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

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

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
workspaceID* | String Workspace ID Required

Body parameters

Name | Description
--- | ---
body * | array of blocks to insert or update

## Responses

###

###

# uploadFile

Upload a binary file, attached to a root block

    /api/v1/workspaces/{workspaceID}/{rootID}/files

### Usage and SDK Samples

    curl -X POST\
    -H "Authorization: [[apiKey]]"\
     -H "Accept: application/json"\
     -H "Content-Type: multipart/form-data"\
     "http://localhost/api/v1/api/v1/workspaces/{workspaceID}/{rootID}/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 workspaceID = workspaceID_example; // String | Workspace ID
            String rootID = rootID_example; // String | ID of the root block
            File uploaded file = BINARY_DATA_HERE; // File | The file to upload

            try {
                FileUploadResponse result = apiInstance.uploadFile(workspaceID, rootID, 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 workspaceID = workspaceID_example; // String | Workspace ID
            String rootID = rootID_example; // String | ID of the root block
            File uploaded file = BINARY_DATA_HERE; // File | The file to upload

            try {
                FileUploadResponse result = apiInstance.uploadFile(workspaceID, rootID, 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 *workspaceID = workspaceID_example; // Workspace ID (default to null)
    String *rootID = rootID_example; // ID of the root block (default to null)
    File *uploaded file = BINARY_DATA_HERE; // The file to upload (optional) (default to null)

    [apiInstance uploadFileWith:workspaceID
        rootID:rootID
        uploaded file:uploaded file
                  completionHandler: ^(FileUploadResponse output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

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

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

    // Create an instance of the API class
    var api = new focalboardServer.DefaultApi()
    var workspaceID = workspaceID_example; // {String} Workspace ID
    var rootID = rootID_example; // {String} ID of the root block
    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(workspaceID, rootID, 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 workspaceID = workspaceID_example;  // String | Workspace ID (default to null)
                var rootID = rootID_example;  // String | ID of the root block (default to null)
                var uploaded file = BINARY_DATA_HERE;  // File | The file to upload (optional)  (default to null)

                try {
                    FileUploadResponse result = apiInstance.uploadFile(workspaceID, rootID, 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();
    $workspaceID = workspaceID_example; // String | Workspace ID
    $rootID = rootID_example; // String | ID of the root block
    $uploaded file = BINARY_DATA_HERE; // File | The file to upload

    try {
        $result = $api_instance->uploadFile($workspaceID, $rootID, $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 $workspaceID = workspaceID_example; # String | Workspace ID
    my $rootID = rootID_example; # String | ID of the root block
    my $uploaded file = BINARY_DATA_HERE; # File | The file to upload

    eval {
        my $result = $api_instance->uploadFile(workspaceID => $workspaceID, rootID => $rootID, 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()
    workspaceID = workspaceID_example # String | Workspace ID (default to null)
    rootID = rootID_example # String | ID of the root block (default to null)
    uploaded file = BINARY_DATA_HERE # File | The file to upload (optional) (default to null)

    try:
        api_response = api_instance.upload_file(workspaceID, rootID, 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 workspaceID = workspaceID_example; // String
        let rootID = rootID_example; // String
        let uploaded file = BINARY_DATA_HERE; // File

        let mut context = DefaultApi::Context::default();
        let result = client.uploadFile(workspaceID, rootID, uploaded file, &context).wait();

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

## Scopes

## Parameters

Path parameters

Name | Description
--- | ---
workspaceID* | String Workspace ID Required
rootID* | String ID of the root block Required

Form parameters

Name | Description
--- | ---
uploaded file | File (binary) The file to upload

## Responses

###

###