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);
}

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);
}

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);
}

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);
}

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);
}

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);
}

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);
}

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);
}

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);
}

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);
}

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);
}

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);
}

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);
}

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);
}

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);
}

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);
}

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);
}