Focalboard Server

Default

addMember

Adds a new member to a board

/boards/{boardID}/members

Usage and SDK Samples

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

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

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

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

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

import org.openapitools.client.api.DefaultApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate DefaultApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
boardID*	String Board ID Required

Body parameters

Name	Description
body *	membership to replace the current one with

Responses

Schema

Schema

archiveExportBoard

Exports an archive of all blocks for one boards.

/boards/{boardID}/archive/export

Usage and SDK Samples

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

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

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

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

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

import org.openapitools.client.api.DefaultApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate DefaultApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
boardID*	String Id of board to export Required

Responses

Schema

archiveExportTeam

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

/teams/{teamID}/archive/export

Usage and SDK Samples

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

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

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

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

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

import org.openapitools.client.api.DefaultApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate DefaultApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
teamID*	String Id of team Required

Responses

Schema

archiveImport

Import an archive of boards.

/teams/{teamID}/archive/import

Usage and SDK Samples

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

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

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

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

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

import org.openapitools.client.api.DefaultApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate DefaultApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
teamID*	String Team ID Required

Form parameters

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

Responses

Schema

changePassword

Change a user's password

/users/{userID}/changepassword

Usage and SDK Samples

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

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

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

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

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

import org.openapitools.client.api.DefaultApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate DefaultApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
userID*	String User ID Required

Body parameters

Name	Description
body *	Change password request

Responses

Schema

Schema

createBoard

Creates a new board

/boards

Usage and SDK Samples

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

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

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

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

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

import org.openapitools.client.api.DefaultApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate DefaultApi;

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

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

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

Scopes

Parameters

Body parameters

Name	Description
body *	the board to create

Responses

Schema

Schema

createCategory

Create a category for boards

/teams/{teamID}/categories

Usage and SDK Samples

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

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

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

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

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

import org.openapitools.client.api.DefaultApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate DefaultApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
teamID*	String Team ID Required

Body parameters

Name	Description
body *	category to create

Responses

Schema

Schema

createSubscription

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

/subscriptions

Usage and SDK Samples

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

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

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

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

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

import org.openapitools.client.api.DefaultApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate DefaultApi;

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

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

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

Scopes

Parameters

Body parameters

Name	Description
body *	subscription definition

Responses

Schema

Schema

deleteBlock

Deletes a block

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

Usage and SDK Samples

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

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

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

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

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

import org.openapitools.client.api.DefaultApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate DefaultApi;

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

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

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

Scopes

Parameters

Path parameters

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

Responses

Schema

deleteBoard

Removes a board

/boards/{boardID}

Usage and SDK Samples

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

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

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

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

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

import org.openapitools.client.api.DefaultApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate DefaultApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
boardID*	String Board ID Required

Responses

Schema

deleteBoardsAndBlocks

Deletes boards and blocks

/boards-and-blocks

Usage and SDK Samples

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

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

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

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

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

import org.openapitools.client.api.DefaultApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate DefaultApi;

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

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

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

Scopes

Parameters

Body parameters

Name	Description
body *	the boards and blocks to delete

Responses

Schema

deleteCategory

Delete a category

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

Usage and SDK Samples

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

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

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

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

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

import org.openapitools.client.api.DefaultApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate DefaultApi;

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

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

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

Scopes

Parameters

Path parameters

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

Responses

Schema

deleteMember

Deletes a member from a board

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

Usage and SDK Samples

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

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

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

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

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

import org.openapitools.client.api.DefaultApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate DefaultApi;

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

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

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

Scopes

Parameters

Path parameters

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

Responses

Schema

deleteSubscription

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

/subscriptions/{blockID}/{subscriberID}

Usage and SDK Samples

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

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

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

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

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

import org.openapitools.client.api.DefaultApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate DefaultApi;

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

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

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

Scopes

Parameters

Path parameters

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

Responses

Schema

duplicateBlock

Returns the new created blocks

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

Usage and SDK Samples

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

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

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

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

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

import org.openapitools.client.api.DefaultApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate DefaultApi;

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

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

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

Scopes

Parameters

Path parameters

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

Responses

Schema

Schema

duplicateBoard

Returns the new created board and all the blocks

/boards/{boardID}/duplicate

Usage and SDK Samples

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

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

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

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

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

import org.openapitools.client.api.DefaultApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate DefaultApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
boardID*	String Board ID Required

Responses

Schema

Schema

getBlocks

Returns blocks

/boards/{boardID}/blocks

Usage and SDK Samples

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

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

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

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

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

import org.openapitools.client.api.DefaultApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate DefaultApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
boardID*	String Board ID Required

Query parameters

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

Responses

Schema

Schema

getBoard

Returns a board

/boards/{boardID}

Usage and SDK Samples

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

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

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

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

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

import org.openapitools.client.api.DefaultApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate DefaultApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
boardID*	String Board ID Required

Responses

Schema

Schema

getBoardMetadata

Returns a board's metadata

/boards/{boardID}/metadata

Usage and SDK Samples

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

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

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

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

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

import org.openapitools.client.api.DefaultApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate DefaultApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
boardID*	String Board ID Required

Responses

Schema

Schema

getBoards

Returns team boards

/teams/{teamID}/boards

Usage and SDK Samples

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

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

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

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

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

import org.openapitools.client.api.DefaultApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate DefaultApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
teamID*	String Team ID Required

Responses

Schema

Schema

getClientConfig

Returns the client configuration

/clientConfig

Usage and SDK Samples

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

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

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

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

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

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

import org.openapitools.client.api.DefaultApi;

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

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



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

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

var FocalboardServer = require('focalboard_server');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Schema

Schema

getMe

Returns the currently logged-in user

/users/me

Usage and SDK Samples

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

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

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

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

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

import org.openapitools.client.api.DefaultApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Schema

Schema

getMembersForBoard

Returns the members of the board

/boards/{boardID}/members

Usage and SDK Samples

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

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

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

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

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

import org.openapitools.client.api.DefaultApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate DefaultApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
boardID*	String Board ID Required

Responses

Schema

Schema

getMyMemberships

Returns the currently users board memberships

/users/me/memberships

Usage and SDK Samples

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

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

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

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

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

import org.openapitools.client.api.DefaultApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Schema

Schema

getSharing

Returns sharing information for a board

/boards/{boardID}/sharing

Usage and SDK Samples

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

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

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

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

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID

        try {
            Sharing result = apiInstance.getSharing(boardID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getSharing");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *boardID = boardID_example; // Board ID (default to null)

[apiInstance getSharingWith:boardID
              completionHandler: ^(Sharing output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var boardID = boardID_example; // {String} Board ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSharing(boardID, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getSharingExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var boardID = boardID_example;  // String | Board ID (default to null)

            try {
                Sharing result = apiInstance.getSharing(boardID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getSharing: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$boardID = boardID_example; // String | Board ID

try {
    $result = $api_instance->getSharing($boardID);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getSharing: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $boardID = boardID_example; # String | Board ID

eval {
    my $result = $api_instance->getSharing(boardID => $boardID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getSharing: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
boardID = boardID_example # String | Board ID (default to null)

try:
    api_response = api_instance.get_sharing(boardID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getSharing: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let boardID = boardID_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getSharing(boardID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
boardID*	String Board ID Required

Responses

Schema

Schema

getSubscriptions

Gets subscriptions for a user.

/subscriptions/{subscriberID}

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/subscriptions/{subscriberID}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String subscriberID = subscriberID_example; // String | Subscriber ID

        try {
            array[User] result = apiInstance.getSubscriptions(subscriberID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getSubscriptions");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String subscriberID = subscriberID_example; // String | Subscriber ID

        try {
            array[User] result = apiInstance.getSubscriptions(subscriberID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getSubscriptions");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *subscriberID = subscriberID_example; // Subscriber ID (default to null)

// Gets subscriptions for a user.
[apiInstance getSubscriptionsWith:subscriberID
              completionHandler: ^(array[User] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var subscriberID = subscriberID_example; // {String} Subscriber ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSubscriptions(subscriberID, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getSubscriptionsExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var subscriberID = subscriberID_example;  // String | Subscriber ID (default to null)

            try {
                // Gets subscriptions for a user.
                array[User] result = apiInstance.getSubscriptions(subscriberID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getSubscriptions: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$subscriberID = subscriberID_example; // String | Subscriber ID

try {
    $result = $api_instance->getSubscriptions($subscriberID);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getSubscriptions: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $subscriberID = subscriberID_example; # String | Subscriber ID

eval {
    my $result = $api_instance->getSubscriptions(subscriberID => $subscriberID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getSubscriptions: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
subscriberID = subscriberID_example # String | Subscriber ID (default to null)

try:
    # Gets subscriptions for a user.
    api_response = api_instance.get_subscriptions(subscriberID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getSubscriptions: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let subscriberID = subscriberID_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getSubscriptions(subscriberID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
subscriberID*	String Subscriber ID Required

Responses

Schema

Schema

getTeam

Returns information of the root team

/teams/{teamID}

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/teams/{teamID}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID

        try {
            Team result = apiInstance.getTeam(teamID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getTeam");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID

        try {
            Team result = apiInstance.getTeam(teamID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getTeam");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *teamID = teamID_example; // Team ID (default to null)

[apiInstance getTeamWith:teamID
              completionHandler: ^(Team output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var teamID = teamID_example; // {String} Team ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTeam(teamID, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getTeamExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var teamID = teamID_example;  // String | Team ID (default to null)

            try {
                Team result = apiInstance.getTeam(teamID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getTeam: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$teamID = teamID_example; // String | Team ID

try {
    $result = $api_instance->getTeam($teamID);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getTeam: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $teamID = teamID_example; # String | Team ID

eval {
    my $result = $api_instance->getTeam(teamID => $teamID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getTeam: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
teamID = teamID_example # String | Team ID (default to null)

try:
    api_response = api_instance.get_team(teamID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getTeam: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let teamID = teamID_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getTeam(teamID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
teamID*	String Team ID Required

Responses

Schema

Schema

getTeamUsers

Returns team users

/teams/{teamID}/users

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/teams/{teamID}/users?search=search_example"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID
        String search = search_example; // String | string to filter users list

        try {
            array[User] result = apiInstance.getTeamUsers(teamID, search);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getTeamUsers");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID
        String search = search_example; // String | string to filter users list

        try {
            array[User] result = apiInstance.getTeamUsers(teamID, search);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getTeamUsers");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *teamID = teamID_example; // Team ID (default to null)
String *search = search_example; // string to filter users list (optional) (default to null)

[apiInstance getTeamUsersWith:teamID
    search:search
              completionHandler: ^(array[User] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var teamID = teamID_example; // {String} Team ID
var opts = {
  'search': search_example // {String} string to filter users list
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTeamUsers(teamID, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getTeamUsersExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var teamID = teamID_example;  // String | Team ID (default to null)
            var search = search_example;  // String | string to filter users list (optional)  (default to null)

            try {
                array[User] result = apiInstance.getTeamUsers(teamID, search);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getTeamUsers: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$teamID = teamID_example; // String | Team ID
$search = search_example; // String | string to filter users list

try {
    $result = $api_instance->getTeamUsers($teamID, $search);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getTeamUsers: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $teamID = teamID_example; # String | Team ID
my $search = search_example; # String | string to filter users list

eval {
    my $result = $api_instance->getTeamUsers(teamID => $teamID, search => $search);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getTeamUsers: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
teamID = teamID_example # String | Team ID (default to null)
search = search_example # String | string to filter users list (optional) (default to null)

try:
    api_response = api_instance.get_team_users(teamID, search=search)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getTeamUsers: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let teamID = teamID_example; // String
    let search = search_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getTeamUsers(teamID, search, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
teamID*	String Team ID Required

Query parameters

Name	Description
search	String string to filter users list

Responses

Schema

Schema

getTeams

Returns information of all the teams

/teams

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/teams"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();

        try {
            array[Team] result = apiInstance.getTeams();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getTeams");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();

        try {
            array[Team] result = apiInstance.getTeams();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getTeams");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance getTeamsWithCompletionHandler: 
              ^(array[Team] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTeams(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getTeamsExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                array[Team] result = apiInstance.getTeams();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getTeams: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $result = $api_instance->getTeams();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getTeams: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval {
    my $result = $api_instance->getTeams();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getTeams: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try:
    api_response = api_instance.get_teams()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getTeams: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

    let mut context = DefaultApi::Context::default();
    let result = client.getTeams(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Schema

Schema

getTemplates

Returns team templates

/teams/{teamID}/templates

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/teams/{teamID}/templates"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID

        try {
            array[Board] result = apiInstance.getTemplates(teamID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getTemplates");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID

        try {
            array[Board] result = apiInstance.getTemplates(teamID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getTemplates");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *teamID = teamID_example; // Team ID (default to null)

[apiInstance getTemplatesWith:teamID
              completionHandler: ^(array[Board] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var teamID = teamID_example; // {String} Team ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTemplates(teamID, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getTemplatesExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var teamID = teamID_example;  // String | Team ID (default to null)

            try {
                array[Board] result = apiInstance.getTemplates(teamID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getTemplates: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$teamID = teamID_example; // String | Team ID

try {
    $result = $api_instance->getTemplates($teamID);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getTemplates: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $teamID = teamID_example; # String | Team ID

eval {
    my $result = $api_instance->getTemplates(teamID => $teamID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getTemplates: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
teamID = teamID_example # String | Team ID (default to null)

try:
    api_response = api_instance.get_templates(teamID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getTemplates: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let teamID = teamID_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getTemplates(teamID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
teamID*	String Team ID Required

Responses

Schema

Schema

getUser

Returns a user

/users/{userID}

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/users/{userID}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String userID = userID_example; // String | User ID

        try {
            User result = apiInstance.getUser(userID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getUser");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String userID = userID_example; // String | User ID

        try {
            User result = apiInstance.getUser(userID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getUser");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *userID = userID_example; // User ID (default to null)

[apiInstance getUserWith:userID
              completionHandler: ^(User output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var userID = userID_example; // {String} User ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getUser(userID, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getUserExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var userID = userID_example;  // String | User ID (default to null)

            try {
                User result = apiInstance.getUser(userID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getUser: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$userID = userID_example; // String | User ID

try {
    $result = $api_instance->getUser($userID);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getUser: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $userID = userID_example; # String | User ID

eval {
    my $result = $api_instance->getUser(userID => $userID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getUser: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
userID = userID_example # String | User ID (default to null)

try:
    api_response = api_instance.get_user(userID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getUser: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let userID = userID_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getUser(userID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
userID*	String User ID Required

Responses

Schema

Schema

getUserCategoryBoards

Gets the user's board categories

/teams/{teamID}/categories

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/teams/{teamID}/categories"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID

        try {
            array[CategoryBoards] result = apiInstance.getUserCategoryBoards(teamID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getUserCategoryBoards");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID

        try {
            array[CategoryBoards] result = apiInstance.getUserCategoryBoards(teamID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getUserCategoryBoards");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *teamID = teamID_example; // Team ID (default to null)

[apiInstance getUserCategoryBoardsWith:teamID
              completionHandler: ^(array[CategoryBoards] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var teamID = teamID_example; // {String} Team ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getUserCategoryBoards(teamID, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getUserCategoryBoardsExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var teamID = teamID_example;  // String | Team ID (default to null)

            try {
                array[CategoryBoards] result = apiInstance.getUserCategoryBoards(teamID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getUserCategoryBoards: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$teamID = teamID_example; // String | Team ID

try {
    $result = $api_instance->getUserCategoryBoards($teamID);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getUserCategoryBoards: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $teamID = teamID_example; # String | Team ID

eval {
    my $result = $api_instance->getUserCategoryBoards(teamID => $teamID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getUserCategoryBoards: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
teamID = teamID_example # String | Team ID (default to null)

try:
    api_response = api_instance.get_user_category_boards(teamID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getUserCategoryBoards: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let teamID = teamID_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getUserCategoryBoards(teamID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
teamID*	String Team ID Required

Responses

Schema

Schema

insertBoardsAndBlocks

Creates new boards and blocks

/boards-and-blocks

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/boards-and-blocks" \
 -d '{
  "blocks" : [ {
    "schema" : 1,
    "createdBy" : "createdBy",
    "deleteAt" : 6,
    "boardId" : "boardId",
    "updateAt" : 5,
    "modifiedBy" : "modifiedBy",
    "id" : "id",
    "fields" : {
      "key" : "{}"
    },
    "title" : "title",
    "type" : "type",
    "createAt" : 0,
    "parentId" : "parentId"
  }, {
    "schema" : 1,
    "createdBy" : "createdBy",
    "deleteAt" : 6,
    "boardId" : "boardId",
    "updateAt" : 5,
    "modifiedBy" : "modifiedBy",
    "id" : "id",
    "fields" : {
      "key" : "{}"
    },
    "title" : "title",
    "type" : "type",
    "createAt" : 0,
    "parentId" : "parentId"
  } ],
  "boards" : [ {
    "deleteAt" : 6,
    "icon" : "icon",
    "description" : "description",
    "updateAt" : 5,
    "title" : "title",
    "type" : "type",
    "createAt" : 0,
    "showDescription" : true,
    "createdBy" : "createdBy",
    "isTemplate" : true,
    "teamId" : "teamId",
    "cardProperties" : [ {
      "key" : "{}"
    }, {
      "key" : "{}"
    } ],
    "modifiedBy" : "modifiedBy",
    "templateVersion" : 1,
    "id" : "id",
    "channelId" : "channelId",
    "properties" : {
      "key" : "{}"
    }
  }, {
    "deleteAt" : 6,
    "icon" : "icon",
    "description" : "description",
    "updateAt" : 5,
    "title" : "title",
    "type" : "type",
    "createAt" : 0,
    "showDescription" : true,
    "createdBy" : "createdBy",
    "isTemplate" : true,
    "teamId" : "teamId",
    "cardProperties" : [ {
      "key" : "{}"
    }, {
      "key" : "{}"
    } ],
    "modifiedBy" : "modifiedBy",
    "templateVersion" : 1,
    "id" : "id",
    "channelId" : "channelId",
    "properties" : {
      "key" : "{}"
    }
  } ]
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        BoardsAndBlocks body = ; // BoardsAndBlocks | 

        try {
            BoardsAndBlocks result = apiInstance.insertBoardsAndBlocks(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#insertBoardsAndBlocks");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        BoardsAndBlocks body = ; // BoardsAndBlocks | 

        try {
            BoardsAndBlocks result = apiInstance.insertBoardsAndBlocks(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#insertBoardsAndBlocks");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
BoardsAndBlocks *body = ; // 

[apiInstance insertBoardsAndBlocksWith:body
              completionHandler: ^(BoardsAndBlocks output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var body = ; // {BoardsAndBlocks} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.insertBoardsAndBlocks(body, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class insertBoardsAndBlocksExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var body = new BoardsAndBlocks(); // BoardsAndBlocks | 

            try {
                BoardsAndBlocks result = apiInstance.insertBoardsAndBlocks(body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.insertBoardsAndBlocks: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$body = ; // BoardsAndBlocks | 

try {
    $result = $api_instance->insertBoardsAndBlocks($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->insertBoardsAndBlocks: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $body = WWW::OPenAPIClient::Object::BoardsAndBlocks->new(); # BoardsAndBlocks | 

eval {
    my $result = $api_instance->insertBoardsAndBlocks(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->insertBoardsAndBlocks: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
body =  # BoardsAndBlocks | 

try:
    api_response = api_instance.insert_boards_and_blocks(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->insertBoardsAndBlocks: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let body = ; // BoardsAndBlocks

    let mut context = DefaultApi::Context::default();
    let result = client.insertBoardsAndBlocks(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters

Name	Description
body *	the boards and blocks to create

Responses

Schema

Schema

joinBoard

Become a member of a board

/boards/{boardID}/join

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/boards/{boardID}/join"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID

        try {
            BoardMember result = apiInstance.joinBoard(boardID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#joinBoard");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID

        try {
            BoardMember result = apiInstance.joinBoard(boardID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#joinBoard");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *boardID = boardID_example; // Board ID (default to null)

[apiInstance joinBoardWith:boardID
              completionHandler: ^(BoardMember output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var boardID = boardID_example; // {String} Board ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.joinBoard(boardID, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class joinBoardExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var boardID = boardID_example;  // String | Board ID (default to null)

            try {
                BoardMember result = apiInstance.joinBoard(boardID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.joinBoard: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$boardID = boardID_example; // String | Board ID

try {
    $result = $api_instance->joinBoard($boardID);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->joinBoard: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $boardID = boardID_example; # String | Board ID

eval {
    my $result = $api_instance->joinBoard(boardID => $boardID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->joinBoard: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
boardID = boardID_example # String | Board ID (default to null)

try:
    api_response = api_instance.join_board(boardID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->joinBoard: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let boardID = boardID_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.joinBoard(boardID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
boardID*	String Board ID Required

Responses

Schema

Schema

leaveBoard

Remove your own membership from a board

/boards/{boardID}/leave

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/boards/{boardID}/leave"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID

        try {
            apiInstance.leaveBoard(boardID);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#leaveBoard");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID

        try {
            apiInstance.leaveBoard(boardID);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#leaveBoard");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *boardID = boardID_example; // Board ID (default to null)

[apiInstance leaveBoardWith:boardID
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var boardID = boardID_example; // {String} Board ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.leaveBoard(boardID, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class leaveBoardExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var boardID = boardID_example;  // String | Board ID (default to null)

            try {
                apiInstance.leaveBoard(boardID);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.leaveBoard: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$boardID = boardID_example; // String | Board ID

try {
    $api_instance->leaveBoard($boardID);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->leaveBoard: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $boardID = boardID_example; # String | Board ID

eval {
    $api_instance->leaveBoard(boardID => $boardID);
};
if ($@) {
    warn "Exception when calling DefaultApi->leaveBoard: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
boardID = boardID_example # String | Board ID (default to null)

try:
    api_instance.leave_board(boardID)
except ApiException as e:
    print("Exception when calling DefaultApi->leaveBoard: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let boardID = boardID_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.leaveBoard(boardID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
boardID*	String Board ID Required

Responses

Schema

login

/login

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/login" \
 -d '{
  "password" : "password",
  "type" : "type",
  "email" : "email",
  "username" : "username"
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        LoginRequest body = ; // LoginRequest | 

        try {
            LoginResponse result = apiInstance.login(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#login");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        LoginRequest body = ; // LoginRequest | 

        try {
            LoginResponse result = apiInstance.login(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#login");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
LoginRequest *body = ; // 

[apiInstance loginWith:body
              completionHandler: ^(LoginResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var FocalboardServer = require('focalboard_server');

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var body = ; // {LoginRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.login(body, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class loginExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var body = new LoginRequest(); // LoginRequest | 

            try {
                LoginResponse result = apiInstance.login(body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.login: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$body = ; // LoginRequest | 

try {
    $result = $api_instance->login($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->login: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $body = WWW::OPenAPIClient::Object::LoginRequest->new(); # LoginRequest | 

eval {
    my $result = $api_instance->login(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->login: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
body =  # LoginRequest | 

try:
    api_response = api_instance.login(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->login: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let body = ; // LoginRequest

    let mut context = DefaultApi::Context::default();
    let result = client.login(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters

Name	Description
body *	Login request

Responses

logout

Logout user

/logout

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/logout"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();

        try {
            apiInstance.logout();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#logout");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();

        try {
            apiInstance.logout();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#logout");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance logoutWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.logout(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class logoutExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                apiInstance.logout();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.logout: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $api_instance->logout();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->logout: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval {
    $api_instance->logout();
};
if ($@) {
    warn "Exception when calling DefaultApi->logout: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try:
    api_instance.logout()
except ApiException as e:
    print("Exception when calling DefaultApi->logout: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

    let mut context = DefaultApi::Context::default();
    let result = client.logout(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Schema

onboard

Onboards a user on Boards.

/team/{teamID}/onboard

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/team/{teamID}/onboard"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID

        try {
            OnboardingResponse result = apiInstance.onboard(teamID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#onboard");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID

        try {
            OnboardingResponse result = apiInstance.onboard(teamID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#onboard");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *teamID = teamID_example; // Team ID (default to null)

// Onboards a user on Boards.
[apiInstance onboardWith:teamID
              completionHandler: ^(OnboardingResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var teamID = teamID_example; // {String} Team ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.onboard(teamID, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class onboardExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var teamID = teamID_example;  // String | Team ID (default to null)

            try {
                // Onboards a user on Boards.
                OnboardingResponse result = apiInstance.onboard(teamID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.onboard: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$teamID = teamID_example; // String | Team ID

try {
    $result = $api_instance->onboard($teamID);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->onboard: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $teamID = teamID_example; # String | Team ID

eval {
    my $result = $api_instance->onboard(teamID => $teamID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->onboard: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
teamID = teamID_example # String | Team ID (default to null)

try:
    # Onboards a user on Boards.
    api_response = api_instance.onboard(teamID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->onboard: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let teamID = teamID_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.onboard(teamID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
teamID*	String Team ID Required

Responses

Schema

Schema

patchBlock

Partially updates a block

/boards/{boardID}/blocks/{blockID}

Usage and SDK Samples

curl -X PATCH \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/boards/{boardID}/blocks/{blockID}" \
 -d '{
  "schema" : 0,
  "updatedFields" : {
    "key" : "{}"
  },
  "boardId" : "boardId",
  "title" : "title",
  "type" : "type",
  "deletedFields" : [ "deletedFields", "deletedFields" ],
  "parentId" : "parentId"
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID
        String blockID = blockID_example; // String | ID of block to patch
        BlockPatch body = ; // BlockPatch | 

        try {
            apiInstance.patchBlock(boardID, blockID, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#patchBlock");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID
        String blockID = blockID_example; // String | ID of block to patch
        BlockPatch body = ; // BlockPatch | 

        try {
            apiInstance.patchBlock(boardID, blockID, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#patchBlock");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *boardID = boardID_example; // Board ID (default to null)
String *blockID = blockID_example; // ID of block to patch (default to null)
BlockPatch *body = ; // 

[apiInstance patchBlockWith:boardID
    blockID:blockID
    body:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var boardID = boardID_example; // {String} Board ID
var blockID = blockID_example; // {String} ID of block to patch
var body = ; // {BlockPatch} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.patchBlock(boardID, blockID, body, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class patchBlockExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var boardID = boardID_example;  // String | Board ID (default to null)
            var blockID = blockID_example;  // String | ID of block to patch (default to null)
            var body = new BlockPatch(); // BlockPatch | 

            try {
                apiInstance.patchBlock(boardID, blockID, body);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.patchBlock: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$boardID = boardID_example; // String | Board ID
$blockID = blockID_example; // String | ID of block to patch
$body = ; // BlockPatch | 

try {
    $api_instance->patchBlock($boardID, $blockID, $body);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->patchBlock: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $boardID = boardID_example; # String | Board ID
my $blockID = blockID_example; # String | ID of block to patch
my $body = WWW::OPenAPIClient::Object::BlockPatch->new(); # BlockPatch | 

eval {
    $api_instance->patchBlock(boardID => $boardID, blockID => $blockID, body => $body);
};
if ($@) {
    warn "Exception when calling DefaultApi->patchBlock: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
boardID = boardID_example # String | Board ID (default to null)
blockID = blockID_example # String | ID of block to patch (default to null)
body =  # BlockPatch | 

try:
    api_instance.patch_block(boardID, blockID, body)
except ApiException as e:
    print("Exception when calling DefaultApi->patchBlock: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let boardID = boardID_example; // String
    let blockID = blockID_example; // String
    let body = ; // BlockPatch

    let mut context = DefaultApi::Context::default();
    let result = client.patchBlock(boardID, blockID, body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
boardID*	String Board ID Required
blockID*	String ID of block to patch Required

Body parameters

Name	Description
body *	block patch to apply

Responses

Schema

patchBlocks

Partially updates batch of blocks

/boards/{boardID}/blocks/

Usage and SDK Samples

curl -X PATCH \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/boards/{boardID}/blocks/" \
 -d '{
  "block_patches" : [ {
    "schema" : 0,
    "updatedFields" : {
      "key" : "{}"
    },
    "boardId" : "boardId",
    "title" : "title",
    "type" : "type",
    "deletedFields" : [ "deletedFields", "deletedFields" ],
    "parentId" : "parentId"
  }, {
    "schema" : 0,
    "updatedFields" : {
      "key" : "{}"
    },
    "boardId" : "boardId",
    "title" : "title",
    "type" : "type",
    "deletedFields" : [ "deletedFields", "deletedFields" ],
    "parentId" : "parentId"
  } ],
  "block_ids" : [ "block_ids", "block_ids" ]
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Workspace ID
        BlockPatchBatch body = ; // BlockPatchBatch | 

        try {
            apiInstance.patchBlocks(boardID, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#patchBlocks");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Workspace ID
        BlockPatchBatch body = ; // BlockPatchBatch | 

        try {
            apiInstance.patchBlocks(boardID, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#patchBlocks");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *boardID = boardID_example; // Workspace ID (default to null)
BlockPatchBatch *body = ; // 

[apiInstance patchBlocksWith:boardID
    body:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var boardID = boardID_example; // {String} Workspace ID
var body = ; // {BlockPatchBatch} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.patchBlocks(boardID, body, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class patchBlocksExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var boardID = boardID_example;  // String | Workspace ID (default to null)
            var body = new BlockPatchBatch(); // BlockPatchBatch | 

            try {
                apiInstance.patchBlocks(boardID, body);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.patchBlocks: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$boardID = boardID_example; // String | Workspace ID
$body = ; // BlockPatchBatch | 

try {
    $api_instance->patchBlocks($boardID, $body);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->patchBlocks: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $boardID = boardID_example; # String | Workspace ID
my $body = WWW::OPenAPIClient::Object::BlockPatchBatch->new(); # BlockPatchBatch | 

eval {
    $api_instance->patchBlocks(boardID => $boardID, body => $body);
};
if ($@) {
    warn "Exception when calling DefaultApi->patchBlocks: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
boardID = boardID_example # String | Workspace ID (default to null)
body =  # BlockPatchBatch | 

try:
    api_instance.patch_blocks(boardID, body)
except ApiException as e:
    print("Exception when calling DefaultApi->patchBlocks: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let boardID = boardID_example; // String
    let body = ; // BlockPatchBatch

    let mut context = DefaultApi::Context::default();
    let result = client.patchBlocks(boardID, body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
boardID*	String Workspace ID Required

Body parameters

Name	Description
body *	block Ids and block patches to apply

Responses

Schema

patchBoard

Partially updates a board

/boards/{boardID}

Usage and SDK Samples

curl -X PATCH \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/boards/{boardID}" \
 -d '{
  "showDescription" : true,
  "updatedProperties" : {
    "key" : "{}"
  },
  "icon" : "icon",
  "deletedCardProperties" : [ "deletedCardProperties", "deletedCardProperties" ],
  "description" : "description",
  "updatedCardProperties" : [ {
    "key" : "{}"
  }, {
    "key" : "{}"
  } ],
  "title" : "title",
  "type" : "type",
  "deletedProperties" : [ "deletedProperties", "deletedProperties" ]
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID
        BoardPatch body = ; // BoardPatch | 

        try {
            Board result = apiInstance.patchBoard(boardID, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#patchBoard");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID
        BoardPatch body = ; // BoardPatch | 

        try {
            Board result = apiInstance.patchBoard(boardID, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#patchBoard");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *boardID = boardID_example; // Board ID (default to null)
BoardPatch *body = ; // 

[apiInstance patchBoardWith:boardID
    body:body
              completionHandler: ^(Board output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var boardID = boardID_example; // {String} Board ID
var body = ; // {BoardPatch} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.patchBoard(boardID, body, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class patchBoardExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var boardID = boardID_example;  // String | Board ID (default to null)
            var body = new BoardPatch(); // BoardPatch | 

            try {
                Board result = apiInstance.patchBoard(boardID, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.patchBoard: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$boardID = boardID_example; // String | Board ID
$body = ; // BoardPatch | 

try {
    $result = $api_instance->patchBoard($boardID, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->patchBoard: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $boardID = boardID_example; # String | Board ID
my $body = WWW::OPenAPIClient::Object::BoardPatch->new(); # BoardPatch | 

eval {
    my $result = $api_instance->patchBoard(boardID => $boardID, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->patchBoard: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
boardID = boardID_example # String | Board ID (default to null)
body =  # BoardPatch | 

try:
    api_response = api_instance.patch_board(boardID, body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->patchBoard: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let boardID = boardID_example; // String
    let body = ; // BoardPatch

    let mut context = DefaultApi::Context::default();
    let result = client.patchBoard(boardID, body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
boardID*	String Board ID Required

Body parameters

Name	Description
body *	board patch to apply

Responses

Schema

Schema

patchBoardsAndBlocks

Patches a set of related boards and blocks

/boards-and-blocks

Usage and SDK Samples

curl -X PATCH \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/boards-and-blocks" \
 -d '{
  "boardIDs" : [ "boardIDs", "boardIDs" ],
  "boardPatches" : [ {
    "showDescription" : true,
    "updatedProperties" : {
      "key" : "{}"
    },
    "icon" : "icon",
    "deletedCardProperties" : [ "deletedCardProperties", "deletedCardProperties" ],
    "description" : "description",
    "updatedCardProperties" : [ {
      "key" : "{}"
    }, {
      "key" : "{}"
    } ],
    "title" : "title",
    "type" : "type",
    "deletedProperties" : [ "deletedProperties", "deletedProperties" ]
  }, {
    "showDescription" : true,
    "updatedProperties" : {
      "key" : "{}"
    },
    "icon" : "icon",
    "deletedCardProperties" : [ "deletedCardProperties", "deletedCardProperties" ],
    "description" : "description",
    "updatedCardProperties" : [ {
      "key" : "{}"
    }, {
      "key" : "{}"
    } ],
    "title" : "title",
    "type" : "type",
    "deletedProperties" : [ "deletedProperties", "deletedProperties" ]
  } ],
  "blockIDs" : [ "blockIDs", "blockIDs" ],
  "blockPatches" : [ {
    "schema" : 0,
    "updatedFields" : {
      "key" : "{}"
    },
    "boardId" : "boardId",
    "title" : "title",
    "type" : "type",
    "deletedFields" : [ "deletedFields", "deletedFields" ],
    "parentId" : "parentId"
  }, {
    "schema" : 0,
    "updatedFields" : {
      "key" : "{}"
    },
    "boardId" : "boardId",
    "title" : "title",
    "type" : "type",
    "deletedFields" : [ "deletedFields", "deletedFields" ],
    "parentId" : "parentId"
  } ]
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        PatchBoardsAndBlocks body = ; // PatchBoardsAndBlocks | 

        try {
            BoardsAndBlocks result = apiInstance.patchBoardsAndBlocks(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#patchBoardsAndBlocks");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        PatchBoardsAndBlocks body = ; // PatchBoardsAndBlocks | 

        try {
            BoardsAndBlocks result = apiInstance.patchBoardsAndBlocks(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#patchBoardsAndBlocks");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
PatchBoardsAndBlocks *body = ; // 

[apiInstance patchBoardsAndBlocksWith:body
              completionHandler: ^(BoardsAndBlocks output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var body = ; // {PatchBoardsAndBlocks} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.patchBoardsAndBlocks(body, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class patchBoardsAndBlocksExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var body = new PatchBoardsAndBlocks(); // PatchBoardsAndBlocks | 

            try {
                BoardsAndBlocks result = apiInstance.patchBoardsAndBlocks(body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.patchBoardsAndBlocks: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$body = ; // PatchBoardsAndBlocks | 

try {
    $result = $api_instance->patchBoardsAndBlocks($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->patchBoardsAndBlocks: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $body = WWW::OPenAPIClient::Object::PatchBoardsAndBlocks->new(); # PatchBoardsAndBlocks | 

eval {
    my $result = $api_instance->patchBoardsAndBlocks(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->patchBoardsAndBlocks: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
body =  # PatchBoardsAndBlocks | 

try:
    api_response = api_instance.patch_boards_and_blocks(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->patchBoardsAndBlocks: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let body = ; // PatchBoardsAndBlocks

    let mut context = DefaultApi::Context::default();
    let result = client.patchBoardsAndBlocks(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters

Name	Description
body *	the patches for the boards and blocks

Responses

Schema

Schema

postSharing

Sets sharing information for a board

/boards/{boardID}/sharing

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/boards/{boardID}/sharing" \
 -d '{
  "update_at" : 0,
  "modifiedBy" : "modifiedBy",
  "id" : "id",
  "enabled" : true,
  "token" : "token"
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID
        Sharing body = ; // Sharing | 

        try {
            apiInstance.postSharing(boardID, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#postSharing");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID
        Sharing body = ; // Sharing | 

        try {
            apiInstance.postSharing(boardID, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#postSharing");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *boardID = boardID_example; // Board ID (default to null)
Sharing *body = ; // 

[apiInstance postSharingWith:boardID
    body:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var boardID = boardID_example; // {String} Board ID
var body = ; // {Sharing} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.postSharing(boardID, body, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class postSharingExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var boardID = boardID_example;  // String | Board ID (default to null)
            var body = new Sharing(); // Sharing | 

            try {
                apiInstance.postSharing(boardID, body);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.postSharing: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$boardID = boardID_example; // String | Board ID
$body = ; // Sharing | 

try {
    $api_instance->postSharing($boardID, $body);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->postSharing: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $boardID = boardID_example; # String | Board ID
my $body = WWW::OPenAPIClient::Object::Sharing->new(); # Sharing | 

eval {
    $api_instance->postSharing(boardID => $boardID, body => $body);
};
if ($@) {
    warn "Exception when calling DefaultApi->postSharing: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
boardID = boardID_example # String | Board ID (default to null)
body =  # Sharing | 

try:
    api_instance.post_sharing(boardID, body)
except ApiException as e:
    print("Exception when calling DefaultApi->postSharing: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let boardID = boardID_example; // String
    let body = ; // Sharing

    let mut context = DefaultApi::Context::default();
    let result = client.postSharing(boardID, body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
boardID*	String Board ID Required

Body parameters

Name	Description
body *	sharing information for a root block

Responses

Schema

regenerateSignupToken

Regenerates the signup token for the root team

/teams/{teamID}/regenerate_signup_token

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/teams/{teamID}/regenerate_signup_token"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID

        try {
            apiInstance.regenerateSignupToken(teamID);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#regenerateSignupToken");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID

        try {
            apiInstance.regenerateSignupToken(teamID);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#regenerateSignupToken");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *teamID = teamID_example; // Team ID (default to null)

[apiInstance regenerateSignupTokenWith:teamID
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var teamID = teamID_example; // {String} Team ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.regenerateSignupToken(teamID, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class regenerateSignupTokenExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var teamID = teamID_example;  // String | Team ID (default to null)

            try {
                apiInstance.regenerateSignupToken(teamID);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.regenerateSignupToken: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$teamID = teamID_example; // String | Team ID

try {
    $api_instance->regenerateSignupToken($teamID);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->regenerateSignupToken: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $teamID = teamID_example; # String | Team ID

eval {
    $api_instance->regenerateSignupToken(teamID => $teamID);
};
if ($@) {
    warn "Exception when calling DefaultApi->regenerateSignupToken: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
teamID = teamID_example # String | Team ID (default to null)

try:
    api_instance.regenerate_signup_token(teamID)
except ApiException as e:
    print("Exception when calling DefaultApi->regenerateSignupToken: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let teamID = teamID_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.regenerateSignupToken(teamID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
teamID*	String Team ID Required

Responses

Schema

register

/register

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/register" \
 -d '{
  "password" : "password",
  "email" : "email",
  "token" : "token",
  "username" : "username"
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        RegisterRequest body = ; // RegisterRequest | 

        try {
            apiInstance.register(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#register");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        RegisterRequest body = ; // RegisterRequest | 

        try {
            apiInstance.register(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#register");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
RegisterRequest *body = ; // 

[apiInstance registerWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var FocalboardServer = require('focalboard_server');

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var body = ; // {RegisterRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.register(body, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class registerExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var body = new RegisterRequest(); // RegisterRequest | 

            try {
                apiInstance.register(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.register: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$body = ; // RegisterRequest | 

try {
    $api_instance->register($body);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->register: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $body = WWW::OPenAPIClient::Object::RegisterRequest->new(); # RegisterRequest | 

eval {
    $api_instance->register(body => $body);
};
if ($@) {
    warn "Exception when calling DefaultApi->register: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
body =  # RegisterRequest | 

try:
    api_instance.register(body)
except ApiException as e:
    print("Exception when calling DefaultApi->register: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let body = ; // RegisterRequest

    let mut context = DefaultApi::Context::default();
    let result = client.register(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters

Name	Description
body *	Register request

Responses

Schema

searchBoards

Returns the boards that match with a search term

/teams/{teamID}/boards/search

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/teams/{teamID}/boards/search?q=q_example"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID
        String q = q_example; // String | The search term. Must have at least one character

        try {
            array[Board] result = apiInstance.searchBoards(teamID, q);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#searchBoards");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID
        String q = q_example; // String | The search term. Must have at least one character

        try {
            array[Board] result = apiInstance.searchBoards(teamID, q);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#searchBoards");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *teamID = teamID_example; // Team ID (default to null)
String *q = q_example; // The search term. Must have at least one character (default to null)

[apiInstance searchBoardsWith:teamID
    q:q
              completionHandler: ^(array[Board] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var teamID = teamID_example; // {String} Team ID
var q = q_example; // {String} The search term. Must have at least one character

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.searchBoards(teamID, q, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class searchBoardsExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var teamID = teamID_example;  // String | Team ID (default to null)
            var q = q_example;  // String | The search term. Must have at least one character (default to null)

            try {
                array[Board] result = apiInstance.searchBoards(teamID, q);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.searchBoards: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$teamID = teamID_example; // String | Team ID
$q = q_example; // String | The search term. Must have at least one character

try {
    $result = $api_instance->searchBoards($teamID, $q);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->searchBoards: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $teamID = teamID_example; # String | Team ID
my $q = q_example; # String | The search term. Must have at least one character

eval {
    my $result = $api_instance->searchBoards(teamID => $teamID, q => $q);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->searchBoards: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
teamID = teamID_example # String | Team ID (default to null)
q = q_example # String | The search term. Must have at least one character (default to null)

try:
    api_response = api_instance.search_boards(teamID, q)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->searchBoards: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let teamID = teamID_example; // String
    let q = q_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.searchBoards(teamID, q, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
teamID*	String Team ID Required

Query parameters

Name	Description
q*	String The search term. Must have at least one character Required

Responses

Schema

Schema

undeleteBlock

Undeletes a block

/boards/{boardID}/blocks/{blockID}/undelete

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/boards/{boardID}/blocks/{blockID}/undelete"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID
        String blockID = blockID_example; // String | ID of block to undelete

        try {
            BlockPatch result = apiInstance.undeleteBlock(boardID, blockID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#undeleteBlock");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID
        String blockID = blockID_example; // String | ID of block to undelete

        try {
            BlockPatch result = apiInstance.undeleteBlock(boardID, blockID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#undeleteBlock");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *boardID = boardID_example; // Board ID (default to null)
String *blockID = blockID_example; // ID of block to undelete (default to null)

[apiInstance undeleteBlockWith:boardID
    blockID:blockID
              completionHandler: ^(BlockPatch output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var boardID = boardID_example; // {String} Board ID
var blockID = blockID_example; // {String} ID of block to undelete

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.undeleteBlock(boardID, blockID, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class undeleteBlockExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var boardID = boardID_example;  // String | Board ID (default to null)
            var blockID = blockID_example;  // String | ID of block to undelete (default to null)

            try {
                BlockPatch result = apiInstance.undeleteBlock(boardID, blockID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.undeleteBlock: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$boardID = boardID_example; // String | Board ID
$blockID = blockID_example; // String | ID of block to undelete

try {
    $result = $api_instance->undeleteBlock($boardID, $blockID);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->undeleteBlock: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $boardID = boardID_example; # String | Board ID
my $blockID = blockID_example; # String | ID of block to undelete

eval {
    my $result = $api_instance->undeleteBlock(boardID => $boardID, blockID => $blockID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->undeleteBlock: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
boardID = boardID_example # String | Board ID (default to null)
blockID = blockID_example # String | ID of block to undelete (default to null)

try:
    api_response = api_instance.undelete_block(boardID, blockID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->undeleteBlock: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let boardID = boardID_example; // String
    let blockID = blockID_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.undeleteBlock(boardID, blockID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
boardID*	String Board ID Required
blockID*	String ID of block to undelete Required

Responses

Schema

Schema

undeleteBoard

Undeletes a board

/boards/{boardID}/undelete

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/boards/{boardID}/undelete"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | ID of board to undelete

        try {
            apiInstance.undeleteBoard(boardID);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#undeleteBoard");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | ID of board to undelete

        try {
            apiInstance.undeleteBoard(boardID);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#undeleteBoard");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *boardID = boardID_example; // ID of board to undelete (default to null)

[apiInstance undeleteBoardWith:boardID
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var boardID = boardID_example; // {String} ID of board to undelete

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.undeleteBoard(boardID, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class undeleteBoardExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var boardID = boardID_example;  // String | ID of board to undelete (default to null)

            try {
                apiInstance.undeleteBoard(boardID);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.undeleteBoard: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$boardID = boardID_example; // String | ID of board to undelete

try {
    $api_instance->undeleteBoard($boardID);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->undeleteBoard: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $boardID = boardID_example; # String | ID of board to undelete

eval {
    $api_instance->undeleteBoard(boardID => $boardID);
};
if ($@) {
    warn "Exception when calling DefaultApi->undeleteBoard: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
boardID = boardID_example # String | ID of board to undelete (default to null)

try:
    api_instance.undelete_board(boardID)
except ApiException as e:
    print("Exception when calling DefaultApi->undeleteBoard: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let boardID = boardID_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.undeleteBoard(boardID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
boardID*	String ID of board to undelete Required

Responses

Schema

updateBlocks

Insert blocks. The specified IDs will only be used to link blocks with existing ones, the rest will be replaced by server generated IDs

/boards/{boardID}/blocks

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/boards/{boardID}/blocks" \
 -d '{
  "schema" : 1,
  "createdBy" : "createdBy",
  "deleteAt" : 6,
  "boardId" : "boardId",
  "updateAt" : 5,
  "modifiedBy" : "modifiedBy",
  "id" : "id",
  "fields" : {
    "key" : "{}"
  },
  "title" : "title",
  "type" : "type",
  "createAt" : 0,
  "parentId" : "parentId"
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID
        array[Block] body = ; // array[Block] | 

        try {
            array[Block] result = apiInstance.updateBlocks(boardID, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateBlocks");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID
        array[Block] body = ; // array[Block] | 

        try {
            array[Block] result = apiInstance.updateBlocks(boardID, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateBlocks");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *boardID = boardID_example; // Board ID (default to null)
array[Block] *body = ; // 

[apiInstance updateBlocksWith:boardID
    body:body
              completionHandler: ^(array[Block] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var boardID = boardID_example; // {String} Board ID
var body = ; // {array[Block]} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateBlocks(boardID, body, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class updateBlocksExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var boardID = boardID_example;  // String | Board ID (default to null)
            var body = new array[Block](); // array[Block] | 

            try {
                array[Block] result = apiInstance.updateBlocks(boardID, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.updateBlocks: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$boardID = boardID_example; // String | Board ID
$body = ; // array[Block] | 

try {
    $result = $api_instance->updateBlocks($boardID, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->updateBlocks: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $boardID = boardID_example; # String | Board ID
my $body = [WWW::OPenAPIClient::Object::array[Block]->new()]; # array[Block] | 

eval {
    my $result = $api_instance->updateBlocks(boardID => $boardID, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->updateBlocks: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
boardID = boardID_example # String | Board ID (default to null)
body =  # array[Block] | 

try:
    api_response = api_instance.update_blocks(boardID, body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->updateBlocks: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let boardID = boardID_example; // String
    let body = ; // array[Block]

    let mut context = DefaultApi::Context::default();
    let result = client.updateBlocks(boardID, body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
boardID*	String Board ID Required

Body parameters

Name	Description
body *	array of blocks to insert or update

Responses

Schema

Schema

updateCategory

Create a category for boards

/teams/{teamID}/categories/{categoryID}

Usage and SDK Samples

curl -X PUT \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/teams/{teamID}/categories/{categoryID}" \
 -d '{
  "deleteAt" : 6,
  "teamID" : "teamID",
  "name" : "name",
  "updateAt" : 1,
  "id" : "id",
  "userID" : "userID",
  "createAt" : 0
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID
        String categoryID = categoryID_example; // String | Category ID
        Category body = ; // Category | 

        try {
            Category result = apiInstance.updateCategory(teamID, categoryID, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateCategory");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID
        String categoryID = categoryID_example; // String | Category ID
        Category body = ; // Category | 

        try {
            Category result = apiInstance.updateCategory(teamID, categoryID, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateCategory");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *teamID = teamID_example; // Team ID (default to null)
String *categoryID = categoryID_example; // Category ID (default to null)
Category *body = ; // 

[apiInstance updateCategoryWith:teamID
    categoryID:categoryID
    body:body
              completionHandler: ^(Category output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var teamID = teamID_example; // {String} Team ID
var categoryID = categoryID_example; // {String} Category ID
var body = ; // {Category} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateCategory(teamID, categoryID, body, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class updateCategoryExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var teamID = teamID_example;  // String | Team ID (default to null)
            var categoryID = categoryID_example;  // String | Category ID (default to null)
            var body = new Category(); // Category | 

            try {
                Category result = apiInstance.updateCategory(teamID, categoryID, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.updateCategory: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$teamID = teamID_example; // String | Team ID
$categoryID = categoryID_example; // String | Category ID
$body = ; // Category | 

try {
    $result = $api_instance->updateCategory($teamID, $categoryID, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->updateCategory: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $teamID = teamID_example; # String | Team ID
my $categoryID = categoryID_example; # String | Category ID
my $body = WWW::OPenAPIClient::Object::Category->new(); # Category | 

eval {
    my $result = $api_instance->updateCategory(teamID => $teamID, categoryID => $categoryID, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->updateCategory: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
teamID = teamID_example # String | Team ID (default to null)
categoryID = categoryID_example # String | Category ID (default to null)
body =  # Category | 

try:
    api_response = api_instance.update_category(teamID, categoryID, body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->updateCategory: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let teamID = teamID_example; // String
    let categoryID = categoryID_example; // String
    let body = ; // Category

    let mut context = DefaultApi::Context::default();
    let result = client.updateCategory(teamID, categoryID, body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
teamID*	String Team ID Required
categoryID*	String Category ID Required

Body parameters

Name	Description
body *	category to update

Responses

Schema

Schema

updateCategoryBoard

Set the category of a board

/teams/{teamID}/categories/{categoryID}/boards/{boardID}

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/teams/{teamID}/categories/{categoryID}/boards/{boardID}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID
        String categoryID = categoryID_example; // String | Category ID
        String boardID = boardID_example; // String | Board ID

        try {
            apiInstance.updateCategoryBoard(teamID, categoryID, boardID);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateCategoryBoard");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID
        String categoryID = categoryID_example; // String | Category ID
        String boardID = boardID_example; // String | Board ID

        try {
            apiInstance.updateCategoryBoard(teamID, categoryID, boardID);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateCategoryBoard");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *teamID = teamID_example; // Team ID (default to null)
String *categoryID = categoryID_example; // Category ID (default to null)
String *boardID = boardID_example; // Board ID (default to null)

[apiInstance updateCategoryBoardWith:teamID
    categoryID:categoryID
    boardID:boardID
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var teamID = teamID_example; // {String} Team ID
var categoryID = categoryID_example; // {String} Category ID
var boardID = boardID_example; // {String} Board ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateCategoryBoard(teamID, categoryID, boardID, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class updateCategoryBoardExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var teamID = teamID_example;  // String | Team ID (default to null)
            var categoryID = categoryID_example;  // String | Category ID (default to null)
            var boardID = boardID_example;  // String | Board ID (default to null)

            try {
                apiInstance.updateCategoryBoard(teamID, categoryID, boardID);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.updateCategoryBoard: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$teamID = teamID_example; // String | Team ID
$categoryID = categoryID_example; // String | Category ID
$boardID = boardID_example; // String | Board ID

try {
    $api_instance->updateCategoryBoard($teamID, $categoryID, $boardID);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->updateCategoryBoard: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $teamID = teamID_example; # String | Team ID
my $categoryID = categoryID_example; # String | Category ID
my $boardID = boardID_example; # String | Board ID

eval {
    $api_instance->updateCategoryBoard(teamID => $teamID, categoryID => $categoryID, boardID => $boardID);
};
if ($@) {
    warn "Exception when calling DefaultApi->updateCategoryBoard: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
teamID = teamID_example # String | Team ID (default to null)
categoryID = categoryID_example # String | Category ID (default to null)
boardID = boardID_example # String | Board ID (default to null)

try:
    api_instance.update_category_board(teamID, categoryID, boardID)
except ApiException as e:
    print("Exception when calling DefaultApi->updateCategoryBoard: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let teamID = teamID_example; // String
    let categoryID = categoryID_example; // String
    let boardID = boardID_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.updateCategoryBoard(teamID, categoryID, boardID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
teamID*	String Team ID Required
categoryID*	String Category ID Required
boardID*	String Board ID Required

Responses

Schema

updateMember

Updates a board member

/boards/{boardID}/members/{userID}

Usage and SDK Samples

curl -X PUT \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/boards/{boardID}/members/{userID}" \
 -d '{
  "schemeAdmin" : true,
  "schemeCommenter" : true,
  "schemeViewer" : true,
  "roles" : "roles",
  "schemeEditor" : true,
  "boardId" : "boardId",
  "userId" : "userId"
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID
        String userID = userID_example; // String | User ID
        BoardMember body = ; // BoardMember | 

        try {
            BoardMember result = apiInstance.updateMember(boardID, userID, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateMember");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID
        String userID = userID_example; // String | User ID
        BoardMember body = ; // BoardMember | 

        try {
            BoardMember result = apiInstance.updateMember(boardID, userID, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateMember");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *boardID = boardID_example; // Board ID (default to null)
String *userID = userID_example; // User ID (default to null)
BoardMember *body = ; // 

[apiInstance updateMemberWith:boardID
    userID:userID
    body:body
              completionHandler: ^(BoardMember output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var boardID = boardID_example; // {String} Board ID
var userID = userID_example; // {String} User ID
var body = ; // {BoardMember} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateMember(boardID, userID, body, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class updateMemberExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var boardID = boardID_example;  // String | Board ID (default to null)
            var userID = userID_example;  // String | User ID (default to null)
            var body = new BoardMember(); // BoardMember | 

            try {
                BoardMember result = apiInstance.updateMember(boardID, userID, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.updateMember: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$boardID = boardID_example; // String | Board ID
$userID = userID_example; // String | User ID
$body = ; // BoardMember | 

try {
    $result = $api_instance->updateMember($boardID, $userID, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->updateMember: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $boardID = boardID_example; # String | Board ID
my $userID = userID_example; # String | User ID
my $body = WWW::OPenAPIClient::Object::BoardMember->new(); # BoardMember | 

eval {
    my $result = $api_instance->updateMember(boardID => $boardID, userID => $userID, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->updateMember: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
boardID = boardID_example # String | Board ID (default to null)
userID = userID_example # String | User ID (default to null)
body =  # BoardMember | 

try:
    api_response = api_instance.update_member(boardID, userID, body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->updateMember: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let boardID = boardID_example; // String
    let userID = userID_example; // String
    let body = ; // BoardMember

    let mut context = DefaultApi::Context::default();
    let result = client.updateMember(boardID, userID, body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
boardID*	String Board ID Required
userID*	String User ID Required

Body parameters

Name	Description
body *	membership to replace the current one with

Responses

Schema

Schema

updateUserConfig

Updates user config

/users/{userID}/config

Usage and SDK Samples

curl -X PATCH \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/users/{userID}/config" \
 -d '{
  "updatedFields" : {
    "key" : "updatedFields"
  },
  "deletedFields" : [ "deletedFields", "deletedFields" ]
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String userID = userID_example; // String | User ID
        UserPropPatch body = ; // UserPropPatch | 

        try {
            apiInstance.updateUserConfig(userID, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateUserConfig");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String userID = userID_example; // String | User ID
        UserPropPatch body = ; // UserPropPatch | 

        try {
            apiInstance.updateUserConfig(userID, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateUserConfig");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *userID = userID_example; // User ID (default to null)
UserPropPatch *body = ; // 

[apiInstance updateUserConfigWith:userID
    body:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var userID = userID_example; // {String} User ID
var body = ; // {UserPropPatch} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateUserConfig(userID, body, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class updateUserConfigExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var userID = userID_example;  // String | User ID (default to null)
            var body = new UserPropPatch(); // UserPropPatch | 

            try {
                apiInstance.updateUserConfig(userID, body);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.updateUserConfig: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$userID = userID_example; // String | User ID
$body = ; // UserPropPatch | 

try {
    $api_instance->updateUserConfig($userID, $body);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->updateUserConfig: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $userID = userID_example; # String | User ID
my $body = WWW::OPenAPIClient::Object::UserPropPatch->new(); # UserPropPatch | 

eval {
    $api_instance->updateUserConfig(userID => $userID, body => $body);
};
if ($@) {
    warn "Exception when calling DefaultApi->updateUserConfig: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
userID = userID_example # String | User ID (default to null)
body =  # UserPropPatch | 

try:
    api_instance.update_user_config(userID, body)
except ApiException as e:
    print("Exception when calling DefaultApi->updateUserConfig: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let userID = userID_example; // String
    let body = ; // UserPropPatch

    let mut context = DefaultApi::Context::default();
    let result = client.updateUserConfig(userID, body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
userID*	String User ID Required

Body parameters

Name	Description
body *	User config patch to apply

Responses

Schema

uploadFile

Upload a binary file, attached to a root block

/teams/{teamID}/boards/{boardID}/files

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: multipart/form-data" \
 "http://localhost/api/v2/teams/{teamID}/boards/{boardID}/files"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | ID of the team
        String boardID = boardID_example; // String | Board ID
        File uploaded file = BINARY_DATA_HERE; // File | The file to upload

        try {
            FileUploadResponse result = apiInstance.uploadFile(teamID, boardID, uploaded file);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#uploadFile");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | ID of the team
        String boardID = boardID_example; // String | Board ID
        File uploaded file = BINARY_DATA_HERE; // File | The file to upload

        try {
            FileUploadResponse result = apiInstance.uploadFile(teamID, boardID, uploaded file);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#uploadFile");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *teamID = teamID_example; // ID of the team (default to null)
String *boardID = boardID_example; // Board ID (default to null)
File *uploaded file = BINARY_DATA_HERE; // The file to upload (optional) (default to null)

[apiInstance uploadFileWith:teamID
    boardID:boardID
    uploaded file:uploaded file
              completionHandler: ^(FileUploadResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var teamID = teamID_example; // {String} ID of the team
var boardID = boardID_example; // {String} Board ID
var opts = {
  'uploaded file': BINARY_DATA_HERE // {File} The file to upload
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.uploadFile(teamID, boardID, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class uploadFileExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var teamID = teamID_example;  // String | ID of the team (default to null)
            var boardID = boardID_example;  // String | Board ID (default to null)
            var uploaded file = BINARY_DATA_HERE;  // File | The file to upload (optional)  (default to null)

            try {
                FileUploadResponse result = apiInstance.uploadFile(teamID, boardID, uploaded file);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.uploadFile: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$teamID = teamID_example; // String | ID of the team
$boardID = boardID_example; // String | Board ID
$uploaded file = BINARY_DATA_HERE; // File | The file to upload

try {
    $result = $api_instance->uploadFile($teamID, $boardID, $uploaded file);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->uploadFile: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $teamID = teamID_example; # String | ID of the team
my $boardID = boardID_example; # String | Board ID
my $uploaded file = BINARY_DATA_HERE; # File | The file to upload

eval {
    my $result = $api_instance->uploadFile(teamID => $teamID, boardID => $boardID, uploaded file => $uploaded file);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->uploadFile: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
teamID = teamID_example # String | ID of the team (default to null)
boardID = boardID_example # String | Board ID (default to null)
uploaded file = BINARY_DATA_HERE # File | The file to upload (optional) (default to null)

try:
    api_response = api_instance.upload_file(teamID, boardID, uploaded file=uploaded file)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->uploadFile: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let teamID = teamID_example; // String
    let boardID = boardID_example; // String
    let uploaded file = BINARY_DATA_HERE; // File

    let mut context = DefaultApi::Context::default();
    let result = client.uploadFile(teamID, boardID, uploaded file, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
teamID*	String ID of the team Required
boardID*	String Board ID Required

Form parameters

Name	Description
uploaded file	File (binary) The file to upload

Responses

Schema

Schema

Focalboard Server

API and SDK Documentation

Default

addMember

Usage and SDK Samples

Scopes

Parameters

Responses

archiveExportBoard

Usage and SDK Samples

Scopes

Parameters

Responses

archiveExportTeam

Usage and SDK Samples

Scopes

Parameters

Responses

archiveImport

Usage and SDK Samples

Scopes

Parameters

Responses

changePassword

Usage and SDK Samples

Scopes

Parameters

Responses

createBoard

Usage and SDK Samples

Scopes

Parameters

Responses

createCategory

Usage and SDK Samples

Scopes

Parameters

Responses

createSubscription

Usage and SDK Samples

Scopes

Parameters

Responses

deleteBlock

Usage and SDK Samples

Scopes

Parameters

Responses

deleteBoard

Usage and SDK Samples

Scopes

Parameters

Responses

deleteBoardsAndBlocks

Usage and SDK Samples

Scopes

Parameters

Responses

deleteCategory

Usage and SDK Samples

Scopes

Parameters

Responses

deleteMember

Usage and SDK Samples

Scopes

Parameters

Responses

deleteSubscription

Usage and SDK Samples

Scopes

Parameters

Responses

duplicateBlock

Usage and SDK Samples

Scopes

Parameters

Responses

duplicateBoard

Usage and SDK Samples