Focalboard Server

Default

addMember

Adds a new member to a board


/boards/{boardID}/members

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/boards/{boardID}/members" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

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

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

        try {
            Object result = apiInstance.addMember(boardID, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#addMember");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


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

[apiInstance addMemberWith:boardID
    body:body
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addMember(boardID, body, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Object result = apiInstance.addMember(boardID, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.addMember: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

eval {
    my $result = $api_instance->addMember(boardID => $boardID, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->addMember: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
boardID*
String
Board ID
Required
Body parameters
Name Description
body *

membership to replace the current one with

Responses


archiveExportBoard

Exports an archive of all blocks for one boards.


/boards/{boardID}/archive/export

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/boards/{boardID}/archive/export"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

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

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

        try {
            apiInstance.archiveExportBoard(boardID);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#archiveExportBoard");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


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

// Exports an archive of all blocks for one boards.
[apiInstance archiveExportBoardWith:boardID
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.archiveExportBoard(boardID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

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

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

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

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

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

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

eval {
    $api_instance->archiveExportBoard(boardID => $boardID);
};
if ($@) {
    warn "Exception when calling DefaultApi->archiveExportBoard: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
boardID*
String
Id of board to export
Required

Responses


archiveExportTeam

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


/teams/{teamID}/archive/export

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/teams/{teamID}/archive/export"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

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

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

        try {
            apiInstance.archiveExportTeam(teamID);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#archiveExportTeam");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


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

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

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.archiveExportTeam(teamID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

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

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

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

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

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

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

eval {
    $api_instance->archiveExportTeam(teamID => $teamID);
};
if ($@) {
    warn "Exception when calling DefaultApi->archiveExportTeam: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
teamID*
String
Id of team
Required

Responses


archiveImport

Import an archive of boards.


/teams/{teamID}/archive/import

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: multipart/form-data" \
 "http://localhost/api/v2/teams/{teamID}/archive/import"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

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

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

        try {
            apiInstance.archiveImport(teamID, file);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#archiveImport");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


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

// Import an archive of boards.
[apiInstance archiveImportWith:teamID
    file:file
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.archiveImport(teamID, file, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                // Import an archive of boards.
                apiInstance.archiveImport(teamID, file);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.archiveImport: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

eval {
    $api_instance->archiveImport(teamID => $teamID, file => $file);
};
if ($@) {
    warn "Exception when calling DefaultApi->archiveImport: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
teamID*
String
Team ID
Required
Form parameters
Name Description
file*
File (binary)
archive file to import
Required

Responses


changePassword

Change a user's password


/users/{userID}/changepassword

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/users/{userID}/changepassword" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

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

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

        try {
            apiInstance.changePassword(userID, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#changePassword");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


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

[apiInstance changePasswordWith:userID
    body:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.changePassword(userID, body, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                apiInstance.changePassword(userID, body);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.changePassword: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

eval {
    $api_instance->changePassword(userID => $userID, body => $body);
};
if ($@) {
    warn "Exception when calling DefaultApi->changePassword: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
userID*
String
User ID
Required
Body parameters
Name Description
body *

Change password request

Responses


cloudLimits

Fetches the cloud limits of the server.


/limits

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/limits"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

        try {
            Object result = apiInstance.cloudLimits();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#cloudLimits");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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

        try {
            Object result = apiInstance.cloudLimits();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#cloudLimits");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


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

// Fetches the cloud limits of the server.
[apiInstance cloudLimitsWithCompletionHandler: 
              ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.cloudLimits(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                // Fetches the cloud limits of the server.
                Object result = apiInstance.cloudLimits();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.cloudLimits: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

try {
    $result = $api_instance->cloudLimits();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->cloudLimits: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

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

eval {
    my $result = $api_instance->cloudLimits();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->cloudLimits: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

try:
    # Fetches the cloud limits of the server.
    api_response = api_instance.cloud_limits()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->cloudLimits: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses


createBoard

Creates a new board


/boards

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/boards" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

        try {
            Object result = apiInstance.createBoard(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createBoard");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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

        try {
            Object result = apiInstance.createBoard(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createBoard");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


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

[apiInstance createBoardWith:body
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createBoard(body, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Object result = apiInstance.createBoard(body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.createBoard: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

eval {
    my $result = $api_instance->createBoard(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createBoard: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

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

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

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

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

Scopes

Parameters

Body parameters
Name Description
body *

the board to create

Responses


createCard

Creates a new card for the specified board.


/boards/{boardID}/cards

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/boards/{boardID}/cards?disable_notify=" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID
        Object body = Object; // Object | 
        oas_any_type_not_mapped disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk data inserting)

        try {
            Object result = apiInstance.createCard(boardID, body, disableNotify);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createCard");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID
        Object body = Object; // Object | 
        oas_any_type_not_mapped disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk data inserting)

        try {
            Object result = apiInstance.createCard(boardID, body, disableNotify);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createCard");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *boardID = boardID_example; // Board ID (default to null)
Object *body = Object; // 
oas_any_type_not_mapped *disableNotify = ; // Disables notifications (for bulk data inserting) (optional) (default to null)

// Creates a new card for the specified board.
[apiInstance createCardWith:boardID
    body:body
    disableNotify:disableNotify
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var boardID = boardID_example; // {String} Board ID
var body = Object; // {Object} 
var opts = {
  'disableNotify':  // {oas_any_type_not_mapped} Disables notifications (for bulk data inserting)
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createCard(boardID, body, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var boardID = boardID_example;  // String | Board ID (default to null)
            var body = Object;  // Object | 
            var disableNotify = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | Disables notifications (for bulk data inserting) (optional)  (default to null)

            try {
                // Creates a new card for the specified board.
                Object result = apiInstance.createCard(boardID, body, disableNotify);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.createCard: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$boardID = boardID_example; // String | Board ID
$body = Object; // Object | 
$disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk data inserting)

try {
    $result = $api_instance->createCard($boardID, $body, $disableNotify);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->createCard: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $boardID = boardID_example; # String | Board ID
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 
my $disableNotify = ; # oas_any_type_not_mapped | Disables notifications (for bulk data inserting)

eval {
    my $result = $api_instance->createCard(boardID => $boardID, body => $body, disableNotify => $disableNotify);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createCard: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
boardID = boardID_example # String | Board ID (default to null)
body = Object # Object | 
disableNotify =  # oas_any_type_not_mapped | Disables notifications (for bulk data inserting) (optional) (default to null)

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
boardID*
String
Board ID
Required
Body parameters
Name Description
body *

the card to create

Query parameters
Name Description
disable_notify
oas_any_type_not_mapped
Disables notifications (for bulk data inserting)

Responses


createCategory

Create a category for boards


/teams/{teamID}/categories

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/teams/{teamID}/categories" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

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

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

        try {
            Object result = apiInstance.createCategory(teamID, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createCategory");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


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

[apiInstance createCategoryWith:teamID
    body:body
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createCategory(teamID, body, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Object result = apiInstance.createCategory(teamID, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.createCategory: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

eval {
    my $result = $api_instance->createCategory(teamID => $teamID, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createCategory: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
teamID*
String
Team ID
Required
Body parameters
Name Description
body *

category to create

Responses


createSubscription

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


/subscriptions

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/subscriptions" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

        try {
            Object result = apiInstance.createSubscription(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createSubscription");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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

        try {
            Object result = apiInstance.createSubscription(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createSubscription");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


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

// Creates a subscription to a block for a user. The user will receive change notifications for the block.
[apiInstance createSubscriptionWith:body
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createSubscription(body, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                // Creates a subscription to a block for a user. The user will receive change notifications for the block.
                Object result = apiInstance.createSubscription(body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.createSubscription: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

eval {
    my $result = $api_instance->createSubscription(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createSubscription: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

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

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

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

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

Scopes

Parameters

Body parameters
Name Description
body *

subscription definition

Responses


deleteBlock

Deletes a block


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

Usage and SDK Samples

curl -X DELETE \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/boards/{boardID}/blocks/{blockID}?disable_notify="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID
        String blockID = blockID_example; // String | ID of block to delete
        oas_any_type_not_mapped disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk deletion)

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

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

        try {
            apiInstance.deleteBlock(boardID, blockID, disableNotify);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteBlock");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *boardID = boardID_example; // Board ID (default to null)
String *blockID = blockID_example; // ID of block to delete (default to null)
oas_any_type_not_mapped *disableNotify = ; // Disables notifications (for bulk deletion) (optional) (default to null)

[apiInstance deleteBlockWith:boardID
    blockID:blockID
    disableNotify:disableNotify
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var boardID = boardID_example; // {String} Board ID
var blockID = blockID_example; // {String} ID of block to delete
var opts = {
  'disableNotify':  // {oas_any_type_not_mapped} Disables notifications (for bulk deletion)
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteBlock(boardID, blockID, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var boardID = boardID_example;  // String | Board ID (default to null)
            var blockID = blockID_example;  // String | ID of block to delete (default to null)
            var disableNotify = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | Disables notifications (for bulk deletion) (optional)  (default to null)

            try {
                apiInstance.deleteBlock(boardID, blockID, disableNotify);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.deleteBlock: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

try {
    $api_instance->deleteBlock($boardID, $blockID, $disableNotify);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteBlock: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

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

eval {
    $api_instance->deleteBlock(boardID => $boardID, blockID => $blockID, disableNotify => $disableNotify);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteBlock: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
boardID = boardID_example # String | Board ID (default to null)
blockID = blockID_example # String | ID of block to delete (default to null)
disableNotify =  # oas_any_type_not_mapped | Disables notifications (for bulk deletion) (optional) (default to null)

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
boardID*
String
Board ID
Required
blockID*
String
ID of block to delete
Required
Query parameters
Name Description
disable_notify
oas_any_type_not_mapped
Disables notifications (for bulk deletion)

Responses


deleteBoard

Removes a board


/boards/{boardID}

Usage and SDK Samples

curl -X DELETE \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/boards/{boardID}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

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

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

        try {
            apiInstance.deleteBoard(boardID);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteBoard");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


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

[apiInstance deleteBoardWith:boardID
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteBoard(boardID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                apiInstance.deleteBoard(boardID);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.deleteBoard: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

eval {
    $api_instance->deleteBoard(boardID => $boardID);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteBoard: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
boardID*
String
Board ID
Required

Responses


deleteBoardsAndBlocks

Deletes boards and blocks


/boards-and-blocks

Usage and SDK Samples

curl -X DELETE \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/boards-and-blocks" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

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

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

        try {
            apiInstance.deleteBoardsAndBlocks(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteBoardsAndBlocks");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


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

[apiInstance deleteBoardsAndBlocksWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteBoardsAndBlocks(body, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                apiInstance.deleteBoardsAndBlocks(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.deleteBoardsAndBlocks: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

eval {
    $api_instance->deleteBoardsAndBlocks(body => $body);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteBoardsAndBlocks: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

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

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

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

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

Scopes

Parameters

Body parameters
Name Description
body *

the boards and blocks to delete

Responses


deleteCategory

Delete a category


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

Usage and SDK Samples

curl -X DELETE \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/teams/{teamID}/categories/{categoryID}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

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

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

        try {
            apiInstance.deleteCategory(teamID, categoryID);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteCategory");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


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

[apiInstance deleteCategoryWith:teamID
    categoryID:categoryID
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteCategory(teamID, categoryID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                apiInstance.deleteCategory(teamID, categoryID);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.deleteCategory: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

eval {
    $api_instance->deleteCategory(teamID => $teamID, categoryID => $categoryID);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteCategory: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

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

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

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

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

Scopes

Parameters

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

Responses


deleteMember

Deletes a member from a board


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

Usage and SDK Samples

curl -X DELETE \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/boards/{boardID}/members/{userID}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

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

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

        try {
            apiInstance.deleteMember(boardID, userID);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteMember");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


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

[apiInstance deleteMemberWith:boardID
    userID:userID
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteMember(boardID, userID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                apiInstance.deleteMember(boardID, userID);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.deleteMember: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

eval {
    $api_instance->deleteMember(boardID => $boardID, userID => $userID);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteMember: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

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

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

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

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

Scopes

Parameters

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

Responses


deleteSubscription

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


/subscriptions/{blockID}/{subscriberID}

Usage and SDK Samples

curl -X DELETE \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/subscriptions/{blockID}/{subscriberID}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

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

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

        try {
            apiInstance.deleteSubscription(blockID, subscriberID);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteSubscription");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


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

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

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteSubscription(blockID, subscriberID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

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

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

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

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

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

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

eval {
    $api_instance->deleteSubscription(blockID => $blockID, subscriberID => $subscriberID);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteSubscription: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

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

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

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

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

Scopes

Parameters

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

Responses


duplicateBlock

Returns the new created blocks


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

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/boards/{boardID}/blocks/{blockID}/duplicate"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

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

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

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

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


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

[apiInstance duplicateBlockWith:boardID
    blockID:blockID
              completionHandler: ^(array[Object] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.duplicateBlock(boardID, blockID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                array[Object] result = apiInstance.duplicateBlock(boardID, blockID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.duplicateBlock: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

eval {
    my $result = $api_instance->duplicateBlock(boardID => $boardID, blockID => $blockID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->duplicateBlock: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

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

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

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

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

Scopes

Parameters

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

Responses


duplicateBoard

Returns the new created board and all the blocks


/boards/{boardID}/duplicate

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/boards/{boardID}/duplicate"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

        try {
            Object result = apiInstance.duplicateBoard(boardID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#duplicateBoard");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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

        try {
            Object result = apiInstance.duplicateBoard(boardID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#duplicateBoard");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


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

[apiInstance duplicateBoardWith:boardID
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.duplicateBoard(boardID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Object result = apiInstance.duplicateBoard(boardID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.duplicateBoard: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

eval {
    my $result = $api_instance->duplicateBoard(boardID => $boardID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->duplicateBoard: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
boardID*
String
Board ID
Required

Responses


getBlocks

Returns blocks


/boards/{boardID}/blocks

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/boards/{boardID}/blocks?parent_id=parentId_example&type=type_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

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

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

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

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


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

[apiInstance getBlocksWith:boardID
    parentId:parentId
    type:type
              completionHandler: ^(array[Object] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getBlocks(boardID, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                array[Object] result = apiInstance.getBlocks(boardID, parentId, type);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getBlocks: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

eval {
    my $result = $api_instance->getBlocks(boardID => $boardID, parentId => $parentId, type => $type);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getBlocks: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
boardID*
String
Board ID
Required
Query parameters
Name Description
parent_id
String
ID of parent block, omit to specify all blocks
type
String
Type of blocks to return, omit to specify all types

Responses


getBoard

Returns a board


/boards/{boardID}

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/boards/{boardID}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

        try {
            Object result = apiInstance.getBoard(boardID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getBoard");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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

        try {
            Object result = apiInstance.getBoard(boardID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getBoard");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


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

[apiInstance getBoardWith:boardID
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getBoard(boardID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Object result = apiInstance.getBoard(boardID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getBoard: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

eval {
    my $result = $api_instance->getBoard(boardID => $boardID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getBoard: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
boardID*
String
Board ID
Required

Responses


getBoardMetadata

Returns a board's metadata


/boards/{boardID}/metadata

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/boards/{boardID}/metadata"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

        try {
            Object result = apiInstance.getBoardMetadata(boardID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getBoardMetadata");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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

        try {
            Object result = apiInstance.getBoardMetadata(boardID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getBoardMetadata");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


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

[apiInstance getBoardMetadataWith:boardID
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getBoardMetadata(boardID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Object result = apiInstance.getBoardMetadata(boardID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getBoardMetadata: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

eval {
    my $result = $api_instance->getBoardMetadata(boardID => $boardID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getBoardMetadata: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
boardID*
String
Board ID
Required

Responses


getBoards

Returns team boards


/teams/{teamID}/boards

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/teams/{teamID}/boards"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

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

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

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

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


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

[apiInstance getBoardsWith:teamID
              completionHandler: ^(array[Object] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getBoards(teamID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                array[Object] result = apiInstance.getBoards(teamID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getBoards: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

eval {
    my $result = $api_instance->getBoards(teamID => $teamID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getBoards: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
teamID*
String
Team ID
Required

Responses


getCard

Fetches the specified card.


/cards/{cardID}

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/cards/{cardID}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String cardID = cardID_example; // String | Card ID

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

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

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

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


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

// Fetches the specified card.
[apiInstance getCardWith:cardID
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var cardID = cardID_example; // {String} Card ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getCard(cardID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var cardID = cardID_example;  // String | Card ID (default to null)

            try {
                // Fetches the specified card.
                Object result = apiInstance.getCard(cardID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getCard: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$cardID = cardID_example; // String | Card ID

try {
    $result = $api_instance->getCard($cardID);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getCard: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

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

eval {
    my $result = $api_instance->getCard(cardID => $cardID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getCard: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
cardID = cardID_example # String | Card ID (default to null)

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
cardID*
String
Card ID
Required

Responses


getCards

Fetches cards for the specified board.


/boards/{boardID}/cards

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/boards/{boardID}/cards?page=56&per_page=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID
        Integer page = 56; // Integer | The page to select (default=0)
        Integer perPage = 56; // Integer | Number of cards to return per page(default=100)

        try {
            array[Object] result = apiInstance.getCards(boardID, page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getCards");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID
        Integer page = 56; // Integer | The page to select (default=0)
        Integer perPage = 56; // Integer | Number of cards to return per page(default=100)

        try {
            array[Object] result = apiInstance.getCards(boardID, page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getCards");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *boardID = boardID_example; // Board ID (default to null)
Integer *page = 56; // The page to select (default=0) (optional) (default to null)
Integer *perPage = 56; // Number of cards to return per page(default=100) (optional) (default to null)

// Fetches cards for the specified board.
[apiInstance getCardsWith:boardID
    page:page
    perPage:perPage
              completionHandler: ^(array[Object] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var boardID = boardID_example; // {String} Board ID
var opts = {
  'page': 56, // {Integer} The page to select (default=0)
  'perPage': 56 // {Integer} Number of cards to return per page(default=100)
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getCards(boardID, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var boardID = boardID_example;  // String | Board ID (default to null)
            var page = 56;  // Integer | The page to select (default=0) (optional)  (default to null)
            var perPage = 56;  // Integer | Number of cards to return per page(default=100) (optional)  (default to null)

            try {
                // Fetches cards for the specified board.
                array[Object] result = apiInstance.getCards(boardID, page, perPage);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getCards: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$boardID = boardID_example; // String | Board ID
$page = 56; // Integer | The page to select (default=0)
$perPage = 56; // Integer | Number of cards to return per page(default=100)

try {
    $result = $api_instance->getCards($boardID, $page, $perPage);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getCards: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $boardID = boardID_example; # String | Board ID
my $page = 56; # Integer | The page to select (default=0)
my $perPage = 56; # Integer | Number of cards to return per page(default=100)

eval {
    my $result = $api_instance->getCards(boardID => $boardID, page => $page, perPage => $perPage);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getCards: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
boardID = boardID_example # String | Board ID (default to null)
page = 56 # Integer | The page to select (default=0) (optional) (default to null)
perPage = 56 # Integer | Number of cards to return per page(default=100) (optional) (default to null)

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
boardID*
String
Board ID
Required
Query parameters
Name Description
page
Integer
The page to select (default=0)
per_page
Integer
Number of cards to return per page(default=100)

Responses


getChannel

Returns the requested channel


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

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/teams/{teamID}/channels/{channelID}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

        try {
            array[Channel] result = apiInstance.getChannel(teamID, channelID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getChannel");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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

        try {
            array[Channel] result = apiInstance.getChannel(teamID, channelID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getChannel");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


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

[apiInstance getChannelWith:teamID
    channelID:channelID
              completionHandler: ^(array[Channel] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getChannel(teamID, channelID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                array[Channel] result = apiInstance.getChannel(teamID, channelID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getChannel: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

try {
    $result = $api_instance->getChannel($teamID, $channelID);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getChannel: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

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

eval {
    my $result = $api_instance->getChannel(teamID => $teamID, channelID => $channelID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getChannel: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
teamID*
String
Team ID
Required
channelID*
String
Channel ID
Required

Responses


getClientConfig

Returns the client configuration


/clientConfig

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/api/v2/clientConfig"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

        try {
            Object result = apiInstance.getClientConfig();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getClientConfig");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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

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


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

[apiInstance getClientConfigWithCompletionHandler: 
              ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');

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

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

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

            try {
                Object result = apiInstance.getClientConfig();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getClientConfig: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

eval {
    my $result = $api_instance->getClientConfig();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getClientConfig: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

pub fn main() {

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

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

Scopes

Parameters

Responses


getFile

Returns the contents of an uploaded file


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

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json,image/jpg,image/png,image/gif" \
 "http://localhost/api/v2/files/teams/{teamID}/{boardID}/{filename}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID
        String boardID = boardID_example; // String | Board ID
        String filename = filename_example; // String | name of the file

        try {
            apiInstance.getFile(teamID, boardID, filename);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getFile");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID
        String boardID = boardID_example; // String | Board ID
        String filename = filename_example; // String | name of the file

        try {
            apiInstance.getFile(teamID, boardID, filename);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getFile");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *teamID = teamID_example; // Team ID (default to null)
String *boardID = boardID_example; // Board ID (default to null)
String *filename = filename_example; // name of the file (default to null)

[apiInstance getFileWith:teamID
    boardID:boardID
    filename:filename
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var teamID = teamID_example; // {String} Team ID
var boardID = boardID_example; // {String} Board ID
var filename = filename_example; // {String} name of the file

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.getFile(teamID, boardID, filename, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var teamID = teamID_example;  // String | Team ID (default to null)
            var boardID = boardID_example;  // String | Board ID (default to null)
            var filename = filename_example;  // String | name of the file (default to null)

            try {
                apiInstance.getFile(teamID, boardID, filename);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getFile: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$teamID = teamID_example; // String | Team ID
$boardID = boardID_example; // String | Board ID
$filename = filename_example; // String | name of the file

try {
    $api_instance->getFile($teamID, $boardID, $filename);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getFile: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

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

eval {
    $api_instance->getFile(teamID => $teamID, boardID => $boardID, filename => $filename);
};
if ($@) {
    warn "Exception when calling DefaultApi->getFile: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
teamID = teamID_example # String | Team ID (default to null)
boardID = boardID_example # String | Board ID (default to null)
filename = filename_example # String | name of the file (default to null)

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
teamID*
String
Team ID
Required
boardID*
String
Board ID
Required
filename*
String
name of the file
Required

Responses


getMe

Returns the currently logged-in user


/users/me

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/users/me"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

        try {
            Object result = apiInstance.getMe();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getMe");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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

        try {
            Object result = apiInstance.getMe();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getMe");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


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

[apiInstance getMeWithCompletionHandler: 
              ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

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

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

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

            try {
                Object result = apiInstance.getMe();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getMe: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

eval {
    my $result = $api_instance->getMe();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getMe: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

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

pub fn main() {

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

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

Scopes

Parameters

Responses


getMembersForBoard

Returns the members of the board


/boards/{boardID}/members

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/boards/{boardID}/members"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

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

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

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

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


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

[apiInstance getMembersForBoardWith:boardID
              completionHandler: ^(array[Object] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getMembersForBoard(boardID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                array[Object] result = apiInstance.getMembersForBoard(boardID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getMembersForBoard: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

eval {
    my $result = $api_instance->getMembersForBoard(boardID => $boardID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getMembersForBoard: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
boardID*
String
Board ID
Required

Responses


getMyMemberships

Returns the currently users board memberships


/users/me/memberships

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/users/me/memberships"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

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

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

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

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


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

[apiInstance getMyMembershipsWithCompletionHandler: 
              ^(array[Object] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

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

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

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

            try {
                array[Object] result = apiInstance.getMyMemberships();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getMyMemberships: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

try {
    $result = $api_instance->getMyMemberships();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getMyMemberships: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

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

eval {
    my $result = $api_instance->getMyMemberships();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getMyMemberships: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

try:
    api_response = api_instance.get_my_memberships()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getMyMemberships: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses


getSharing

Returns sharing information for a board


/boards/{boardID}/sharing

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/boards/{boardID}/sharing"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

        try {
            Object result = apiInstance.getSharing(boardID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getSharing");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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

        try {
            Object result = apiInstance.getSharing(boardID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getSharing");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


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

[apiInstance getSharingWith:boardID
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSharing(boardID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Object result = apiInstance.getSharing(boardID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getSharing: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

try {
    $result = $api_instance->getSharing($boardID);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getSharing: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

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

eval {
    my $result = $api_instance->getSharing(boardID => $boardID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getSharing: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

try:
    api_response = api_instance.get_sharing(boardID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getSharing: %s\n" % e)
extern crate DefaultApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
boardID*
String
Board ID
Required

Responses


getSubscriptions

Gets subscriptions for a user.


/subscriptions/{subscriberID}

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/subscriptions/{subscriberID}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

        try {
            array[Object] result = apiInstance.getSubscriptions(subscriberID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getSubscriptions");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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

        try {
            array[Object] result = apiInstance.getSubscriptions(subscriberID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getSubscriptions");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


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

// Gets subscriptions for a user.
[apiInstance getSubscriptionsWith:subscriberID
              completionHandler: ^(array[Object] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSubscriptions(subscriberID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                // Gets subscriptions for a user.
                array[Object] result = apiInstance.getSubscriptions(subscriberID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getSubscriptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

try {
    $result = $api_instance->getSubscriptions($subscriberID);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getSubscriptions: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

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

eval {
    my $result = $api_instance->getSubscriptions(subscriberID => $subscriberID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getSubscriptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

try:
    # Gets subscriptions for a user.
    api_response = api_instance.get_subscriptions(subscriberID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getSubscriptions: %s\n" % e)
extern crate DefaultApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
subscriberID*
String
Subscriber ID
Required

Responses


getTeam

Returns information of the root team


/teams/{teamID}

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/teams/{teamID}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

        try {
            Object result = apiInstance.getTeam(teamID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getTeam");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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

        try {
            Object result = apiInstance.getTeam(teamID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getTeam");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


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

[apiInstance getTeamWith:teamID
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTeam(teamID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Object result = apiInstance.getTeam(teamID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getTeam: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

try {
    $result = $api_instance->getTeam($teamID);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getTeam: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

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

eval {
    my $result = $api_instance->getTeam(teamID => $teamID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getTeam: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

try:
    api_response = api_instance.get_team(teamID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getTeam: %s\n" % e)
extern crate DefaultApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
teamID*
String
Team ID
Required

Responses


getTeamUsers

Returns team users


/teams/{teamID}/users

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/teams/{teamID}/users?search=search_example&exclude_bots=true"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID
        String search = search_example; // String | string to filter users list
        Boolean excludeBots = true; // Boolean | exclude bot users

        try {
            array[Object] result = apiInstance.getTeamUsers(teamID, search, excludeBots);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getTeamUsers");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID
        String search = search_example; // String | string to filter users list
        Boolean excludeBots = true; // Boolean | exclude bot users

        try {
            array[Object] result = apiInstance.getTeamUsers(teamID, search, excludeBots);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getTeamUsers");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *teamID = teamID_example; // Team ID (default to null)
String *search = search_example; // string to filter users list (optional) (default to null)
Boolean *excludeBots = true; // exclude bot users (optional) (default to null)

[apiInstance getTeamUsersWith:teamID
    search:search
    excludeBots:excludeBots
              completionHandler: ^(array[Object] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var teamID = teamID_example; // {String} Team ID
var opts = {
  'search': search_example, // {String} string to filter users list
  'excludeBots': true // {Boolean} exclude bot users
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTeamUsers(teamID, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var teamID = teamID_example;  // String | Team ID (default to null)
            var search = search_example;  // String | string to filter users list (optional)  (default to null)
            var excludeBots = true;  // Boolean | exclude bot users (optional)  (default to null)

            try {
                array[Object] result = apiInstance.getTeamUsers(teamID, search, excludeBots);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getTeamUsers: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$teamID = teamID_example; // String | Team ID
$search = search_example; // String | string to filter users list
$excludeBots = true; // Boolean | exclude bot users

try {
    $result = $api_instance->getTeamUsers($teamID, $search, $excludeBots);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getTeamUsers: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $teamID = teamID_example; # String | Team ID
my $search = search_example; # String | string to filter users list
my $excludeBots = true; # Boolean | exclude bot users

eval {
    my $result = $api_instance->getTeamUsers(teamID => $teamID, search => $search, excludeBots => $excludeBots);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getTeamUsers: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
teamID = teamID_example # String | Team ID (default to null)
search = search_example # String | string to filter users list (optional) (default to null)
excludeBots = true # Boolean | exclude bot users (optional) (default to null)

try:
    api_response = api_instance.get_team_users(teamID, search=search, excludeBots=excludeBots)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getTeamUsers: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let teamID = teamID_example; // String
    let search = search_example; // String
    let excludeBots = true; // Boolean

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

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

Scopes

Parameters

Path parameters
Name Description
teamID*
String
Team ID
Required
Query parameters
Name Description
search
exclude_bots
Boolean
exclude bot users

Responses


getTeams

Returns information of all the teams


/teams

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/teams"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

        try {
            array[Object] result = apiInstance.getTeams();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getTeams");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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

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

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


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

[apiInstance getTeamsWithCompletionHandler: 
              ^(array[Object] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTeams(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                array[Object] result = apiInstance.getTeams();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getTeams: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

try {
    $result = $api_instance->getTeams();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getTeams: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

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

eval {
    my $result = $api_instance->getTeams();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getTeams: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

try:
    api_response = api_instance.get_teams()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getTeams: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses


getTemplates

Returns team templates


/teams/{teamID}/templates

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/teams/{teamID}/templates"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

        try {
            array[Object] result = apiInstance.getTemplates(teamID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getTemplates");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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

        try {
            array[Object] result = apiInstance.getTemplates(teamID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getTemplates");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


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

[apiInstance getTemplatesWith:teamID
              completionHandler: ^(array[Object] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTemplates(teamID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                array[Object] result = apiInstance.getTemplates(teamID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getTemplates: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

try {
    $result = $api_instance->getTemplates($teamID);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getTemplates: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

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

eval {
    my $result = $api_instance->getTemplates(teamID => $teamID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getTemplates: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

try:
    api_response = api_instance.get_templates(teamID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getTemplates: %s\n" % e)
extern crate DefaultApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
teamID*
String
Team ID
Required

Responses


getUser

Returns a user


/users/{userID}

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/users/{userID}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

        try {
            Object result = apiInstance.getUser(userID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getUser");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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

        try {
            Object result = apiInstance.getUser(userID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getUser");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


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

[apiInstance getUserWith:userID
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getUser(userID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Object result = apiInstance.getUser(userID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getUser: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

eval {
    my $result = $api_instance->getUser(userID => $userID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getUser: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
userID*
String
User ID
Required

Responses


getUserBoardsInsights

Returns user boards insights


/users/me/boards/insights

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/users/me/boards/insights?time_range=timeRange_example&page=page_example&per_page=perPage_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID
        String timeRange = timeRange_example; // String | duration of data to calculate insights for
        String page = page_example; // String | page offset for top boards
        String perPage = perPage_example; // String | limit for boards in a page.

        try {
            array[Object] result = apiInstance.getUserBoardsInsights(teamID, timeRange, page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getUserBoardsInsights");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID
        String timeRange = timeRange_example; // String | duration of data to calculate insights for
        String page = page_example; // String | page offset for top boards
        String perPage = perPage_example; // String | limit for boards in a page.

        try {
            array[Object] result = apiInstance.getUserBoardsInsights(teamID, timeRange, page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getUserBoardsInsights");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *teamID = teamID_example; // Team ID (default to null)
String *timeRange = timeRange_example; // duration of data to calculate insights for (default to null)
String *page = page_example; // page offset for top boards (default to null)
String *perPage = perPage_example; // limit for boards in a page. (default to null)

[apiInstance getUserBoardsInsightsWith:teamID
    timeRange:timeRange
    page:page
    perPage:perPage
              completionHandler: ^(array[Object] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var teamID = teamID_example; // {String} Team ID
var timeRange = timeRange_example; // {String} duration of data to calculate insights for
var page = page_example; // {String} page offset for top boards
var perPage = perPage_example; // {String} limit for boards in a page.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getUserBoardsInsights(teamID, timeRange, page, perPage, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var teamID = teamID_example;  // String | Team ID (default to null)
            var timeRange = timeRange_example;  // String | duration of data to calculate insights for (default to null)
            var page = page_example;  // String | page offset for top boards (default to null)
            var perPage = perPage_example;  // String | limit for boards in a page. (default to null)

            try {
                array[Object] result = apiInstance.getUserBoardsInsights(teamID, timeRange, page, perPage);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getUserBoardsInsights: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$teamID = teamID_example; // String | Team ID
$timeRange = timeRange_example; // String | duration of data to calculate insights for
$page = page_example; // String | page offset for top boards
$perPage = perPage_example; // String | limit for boards in a page.

try {
    $result = $api_instance->getUserBoardsInsights($teamID, $timeRange, $page, $perPage);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getUserBoardsInsights: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $teamID = teamID_example; # String | Team ID
my $timeRange = timeRange_example; # String | duration of data to calculate insights for
my $page = page_example; # String | page offset for top boards
my $perPage = perPage_example; # String | limit for boards in a page.

eval {
    my $result = $api_instance->getUserBoardsInsights(teamID => $teamID, timeRange => $timeRange, page => $page, perPage => $perPage);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getUserBoardsInsights: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
teamID = teamID_example # String | Team ID (default to null)
timeRange = timeRange_example # String | duration of data to calculate insights for (default to null)
page = page_example # String | page offset for top boards (default to null)
perPage = perPage_example # String | limit for boards in a page. (default to null)

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
teamID*
String
Team ID
Required
Query parameters
Name Description
time_range*
String
duration of data to calculate insights for
Required
page*
String
page offset for top boards
Required
per_page*
String
limit for boards in a page.
Required

Responses


getUserCategoryBoards

Gets the user's board categories


/teams/{teamID}/categories

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/teams/{teamID}/categories"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

        try {
            array[Object] result = apiInstance.getUserCategoryBoards(teamID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getUserCategoryBoards");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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

        try {
            array[Object] result = apiInstance.getUserCategoryBoards(teamID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getUserCategoryBoards");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


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

[apiInstance getUserCategoryBoardsWith:teamID
              completionHandler: ^(array[Object] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getUserCategoryBoards(teamID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                array[Object] result = apiInstance.getUserCategoryBoards(teamID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getUserCategoryBoards: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

try {
    $result = $api_instance->getUserCategoryBoards($teamID);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getUserCategoryBoards: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

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

eval {
    my $result = $api_instance->getUserCategoryBoards(teamID => $teamID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getUserCategoryBoards: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

try:
    api_response = api_instance.get_user_category_boards(teamID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getUserCategoryBoards: %s\n" % e)
extern crate DefaultApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
teamID*
String
Team ID
Required

Responses


getUserConfig

Returns an array of user preferences


/users/me/config

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/users/me/config"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

        try {
            Preferences result = apiInstance.getUserConfig();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getUserConfig");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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

        try {
            Preferences result = apiInstance.getUserConfig();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getUserConfig");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


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

[apiInstance getUserConfigWithCompletionHandler: 
              ^(Preferences output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getUserConfig(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Preferences result = apiInstance.getUserConfig();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getUserConfig: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

try {
    $result = $api_instance->getUserConfig();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getUserConfig: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

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

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

eval {
    my $result = $api_instance->getUserConfig();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getUserConfig: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

try:
    api_response = api_instance.get_user_config()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getUserConfig: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses


getUsersList

Returns a user[]


/users

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/users"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

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

        try {
            Object result = apiInstance.getUsersList(userID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getUsersList");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

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

        try {
            Object result = apiInstance.getUsersList(userID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getUsersList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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


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

[apiInstance getUsersListWith:userID
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

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

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var userID = userID_example; // {String} User ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getUsersList(userID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getUsersListExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var userID = userID_example;  // String | User ID (default to null)

            try {
                Object result = apiInstance.getUsersList(userID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getUsersList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$userID = userID_example; // String | User ID

try {
    $result = $api_instance->getUsersList($userID);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getUsersList: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $userID = userID_example; # String | User ID

eval {
    my $result = $api_instance->getUsersList(userID => $userID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getUsersList: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
userID = userID_example # String | User ID (default to null)

try:
    api_response = api_instance.get_users_list(userID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getUsersList: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let userID = userID_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getUsersList(userID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
userID*
String
User ID
Required

Responses


handleNotifyAdminUpgrade

Notifies admins for upgrade request.


/api/v2/teams/{teamID}/notifyadminupgrade

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/api/v2/teams/{teamID}/notifyadminupgrade"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID

        try {
            apiInstance.handleNotifyAdminUpgrade(teamID);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#handleNotifyAdminUpgrade");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID

        try {
            apiInstance.handleNotifyAdminUpgrade(teamID);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#handleNotifyAdminUpgrade");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *teamID = teamID_example; // Team ID (default to null)

// Notifies admins for upgrade request.
[apiInstance handleNotifyAdminUpgradeWith:teamID
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var teamID = teamID_example; // {String} Team ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.handleNotifyAdminUpgrade(teamID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class handleNotifyAdminUpgradeExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var teamID = teamID_example;  // String | Team ID (default to null)

            try {
                // Notifies admins for upgrade request.
                apiInstance.handleNotifyAdminUpgrade(teamID);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.handleNotifyAdminUpgrade: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$teamID = teamID_example; // String | Team ID

try {
    $api_instance->handleNotifyAdminUpgrade($teamID);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->handleNotifyAdminUpgrade: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $teamID = teamID_example; # String | Team ID

eval {
    $api_instance->handleNotifyAdminUpgrade(teamID => $teamID);
};
if ($@) {
    warn "Exception when calling DefaultApi->handleNotifyAdminUpgrade: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
teamID = teamID_example # String | Team ID (default to null)

try:
    # Notifies admins for upgrade request.
    api_instance.handle_notify_admin_upgrade(teamID)
except ApiException as e:
    print("Exception when calling DefaultApi->handleNotifyAdminUpgrade: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let teamID = teamID_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.handleNotifyAdminUpgrade(teamID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
teamID*
String
Team ID
Required

Responses


handleStatistics

Fetches the statistic of the server.


/statistics

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/statistics"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();

        try {
            BoardStatistics result = apiInstance.handleStatistics();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#handleStatistics");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();

        try {
            BoardStatistics result = apiInstance.handleStatistics();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#handleStatistics");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Fetches the statistic  of the server.
[apiInstance handleStatisticsWithCompletionHandler: 
              ^(BoardStatistics output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.handleStatistics(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class handleStatisticsExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                // Fetches the statistic  of the server.
                BoardStatistics result = apiInstance.handleStatistics();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.handleStatistics: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $result = $api_instance->handleStatistics();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->handleStatistics: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval {
    my $result = $api_instance->handleStatistics();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->handleStatistics: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try:
    # Fetches the statistic  of the server.
    api_response = api_instance.handle_statistics()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->handleStatistics: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

    let mut context = DefaultApi::Context::default();
    let result = client.handleStatistics(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


handleTeamBoardsInsights

Returns team boards insights


/teams/{teamID}/boards/insights

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/teams/{teamID}/boards/insights?time_range=timeRange_example&page=page_example&per_page=perPage_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID
        String timeRange = timeRange_example; // String | duration of data to calculate insights for
        String page = page_example; // String | page offset for top boards
        String perPage = perPage_example; // String | limit for boards in a page.

        try {
            array[Object] result = apiInstance.handleTeamBoardsInsights(teamID, timeRange, page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#handleTeamBoardsInsights");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID
        String timeRange = timeRange_example; // String | duration of data to calculate insights for
        String page = page_example; // String | page offset for top boards
        String perPage = perPage_example; // String | limit for boards in a page.

        try {
            array[Object] result = apiInstance.handleTeamBoardsInsights(teamID, timeRange, page, perPage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#handleTeamBoardsInsights");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *teamID = teamID_example; // Team ID (default to null)
String *timeRange = timeRange_example; // duration of data to calculate insights for (default to null)
String *page = page_example; // page offset for top boards (default to null)
String *perPage = perPage_example; // limit for boards in a page. (default to null)

[apiInstance handleTeamBoardsInsightsWith:teamID
    timeRange:timeRange
    page:page
    perPage:perPage
              completionHandler: ^(array[Object] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var teamID = teamID_example; // {String} Team ID
var timeRange = timeRange_example; // {String} duration of data to calculate insights for
var page = page_example; // {String} page offset for top boards
var perPage = perPage_example; // {String} limit for boards in a page.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.handleTeamBoardsInsights(teamID, timeRange, page, perPage, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class handleTeamBoardsInsightsExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var teamID = teamID_example;  // String | Team ID (default to null)
            var timeRange = timeRange_example;  // String | duration of data to calculate insights for (default to null)
            var page = page_example;  // String | page offset for top boards (default to null)
            var perPage = perPage_example;  // String | limit for boards in a page. (default to null)

            try {
                array[Object] result = apiInstance.handleTeamBoardsInsights(teamID, timeRange, page, perPage);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.handleTeamBoardsInsights: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$teamID = teamID_example; // String | Team ID
$timeRange = timeRange_example; // String | duration of data to calculate insights for
$page = page_example; // String | page offset for top boards
$perPage = perPage_example; // String | limit for boards in a page.

try {
    $result = $api_instance->handleTeamBoardsInsights($teamID, $timeRange, $page, $perPage);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->handleTeamBoardsInsights: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $teamID = teamID_example; # String | Team ID
my $timeRange = timeRange_example; # String | duration of data to calculate insights for
my $page = page_example; # String | page offset for top boards
my $perPage = perPage_example; # String | limit for boards in a page.

eval {
    my $result = $api_instance->handleTeamBoardsInsights(teamID => $teamID, timeRange => $timeRange, page => $page, perPage => $perPage);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->handleTeamBoardsInsights: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
teamID = teamID_example # String | Team ID (default to null)
timeRange = timeRange_example # String | duration of data to calculate insights for (default to null)
page = page_example # String | page offset for top boards (default to null)
perPage = perPage_example # String | limit for boards in a page. (default to null)

try:
    api_response = api_instance.handle_team_boards_insights(teamID, timeRange, page, perPage)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->handleTeamBoardsInsights: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let teamID = teamID_example; // String
    let timeRange = timeRange_example; // String
    let page = page_example; // String
    let perPage = perPage_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.handleTeamBoardsInsights(teamID, timeRange, page, perPage, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
teamID*
String
Team ID
Required
Query parameters
Name Description
time_range*
String
duration of data to calculate insights for
Required
page*
String
page offset for top boards
Required
per_page*
String
limit for boards in a page.
Required

Responses


hello

Responds with `Hello` if the web service is running.


/hello

Usage and SDK Samples

curl -X GET \
 "http://localhost/api/v2/hello"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();

        try {
            apiInstance.hello();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#hello");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();

        try {
            apiInstance.hello();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#hello");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Responds with `Hello` if the web service is running.
[apiInstance helloWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.hello(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class helloExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                // Responds with `Hello` if the web service is running.
                apiInstance.hello();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.hello: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $api_instance->hello();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->hello: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval {
    $api_instance->hello();
};
if ($@) {
    warn "Exception when calling DefaultApi->hello: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try:
    # Responds with `Hello` if the web service is running.
    api_instance.hello()
except ApiException as e:
    print("Exception when calling DefaultApi->hello: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

    let mut context = DefaultApi::Context::default();
    let result = client.hello(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


insertBoardsAndBlocks

Creates new boards and blocks


/boards-and-blocks

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/boards-and-blocks" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.insertBoardsAndBlocks(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#insertBoardsAndBlocks");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.insertBoardsAndBlocks(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#insertBoardsAndBlocks");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
Object *body = Object; // 

[apiInstance insertBoardsAndBlocksWith:body
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var body = Object; // {Object} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.insertBoardsAndBlocks(body, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class insertBoardsAndBlocksExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var body = Object;  // Object | 

            try {
                Object result = apiInstance.insertBoardsAndBlocks(body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.insertBoardsAndBlocks: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$body = Object; // Object | 

try {
    $result = $api_instance->insertBoardsAndBlocks($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->insertBoardsAndBlocks: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    my $result = $api_instance->insertBoardsAndBlocks(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->insertBoardsAndBlocks: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
body = Object # Object | 

try:
    api_response = api_instance.insert_boards_and_blocks(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->insertBoardsAndBlocks: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let body = Object; // Object

    let mut context = DefaultApi::Context::default();
    let result = client.insertBoardsAndBlocks(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body *

the boards and blocks to create

Responses


joinBoard

Become a member of a board


/boards/{boardID}/join

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/boards/{boardID}/join"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID

        try {
            Object result = apiInstance.joinBoard(boardID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#joinBoard");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID

        try {
            Object result = apiInstance.joinBoard(boardID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#joinBoard");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *boardID = boardID_example; // Board ID (default to null)

[apiInstance joinBoardWith:boardID
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var boardID = boardID_example; // {String} Board ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.joinBoard(boardID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class joinBoardExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var boardID = boardID_example;  // String | Board ID (default to null)

            try {
                Object result = apiInstance.joinBoard(boardID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.joinBoard: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$boardID = boardID_example; // String | Board ID

try {
    $result = $api_instance->joinBoard($boardID);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->joinBoard: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $boardID = boardID_example; # String | Board ID

eval {
    my $result = $api_instance->joinBoard(boardID => $boardID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->joinBoard: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
boardID = boardID_example # String | Board ID (default to null)

try:
    api_response = api_instance.join_board(boardID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->joinBoard: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let boardID = boardID_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.joinBoard(boardID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
boardID*
String
Board ID
Required

Responses


leaveBoard

Remove your own membership from a board


/boards/{boardID}/leave

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/boards/{boardID}/leave"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID

        try {
            apiInstance.leaveBoard(boardID);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#leaveBoard");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID

        try {
            apiInstance.leaveBoard(boardID);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#leaveBoard");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *boardID = boardID_example; // Board ID (default to null)

[apiInstance leaveBoardWith:boardID
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var boardID = boardID_example; // {String} Board ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.leaveBoard(boardID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class leaveBoardExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var boardID = boardID_example;  // String | Board ID (default to null)

            try {
                apiInstance.leaveBoard(boardID);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.leaveBoard: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$boardID = boardID_example; // String | Board ID

try {
    $api_instance->leaveBoard($boardID);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->leaveBoard: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $boardID = boardID_example; # String | Board ID

eval {
    $api_instance->leaveBoard(boardID => $boardID);
};
if ($@) {
    warn "Exception when calling DefaultApi->leaveBoard: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
boardID = boardID_example # String | Board ID (default to null)

try:
    api_instance.leave_board(boardID)
except ApiException as e:
    print("Exception when calling DefaultApi->leaveBoard: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let boardID = boardID_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.leaveBoard(boardID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
boardID*
String
Board ID
Required

Responses


login

Login user


/login

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/login" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.login(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#login");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.login(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#login");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
Object *body = Object; // 

[apiInstance loginWith:body
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var body = Object; // {Object} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.login(body, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class loginExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var body = Object;  // Object | 

            try {
                Object result = apiInstance.login(body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.login: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$body = Object; // Object | 

try {
    $result = $api_instance->login($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->login: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    my $result = $api_instance->login(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->login: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
body = Object # Object | 

try:
    api_response = api_instance.login(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->login: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let body = Object; // Object

    let mut context = DefaultApi::Context::default();
    let result = client.login(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body *

Login request

Responses


logout

Logout user


/logout

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/logout"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();

        try {
            apiInstance.logout();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#logout");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();

        try {
            apiInstance.logout();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#logout");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];

[apiInstance logoutWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.logout(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class logoutExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                apiInstance.logout();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.logout: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $api_instance->logout();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->logout: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval {
    $api_instance->logout();
};
if ($@) {
    warn "Exception when calling DefaultApi->logout: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try:
    api_instance.logout()
except ApiException as e:
    print("Exception when calling DefaultApi->logout: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

    let mut context = DefaultApi::Context::default();
    let result = client.logout(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


onboard

Onboards a user on Boards.


/team/{teamID}/onboard

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/team/{teamID}/onboard"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID

        try {
            onboard_200_response result = apiInstance.onboard(teamID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#onboard");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID

        try {
            onboard_200_response result = apiInstance.onboard(teamID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#onboard");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *teamID = teamID_example; // Team ID (default to null)

// Onboards a user on Boards.
[apiInstance onboardWith:teamID
              completionHandler: ^(onboard_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var teamID = teamID_example; // {String} Team ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.onboard(teamID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class onboardExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var teamID = teamID_example;  // String | Team ID (default to null)

            try {
                // Onboards a user on Boards.
                onboard_200_response result = apiInstance.onboard(teamID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.onboard: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$teamID = teamID_example; // String | Team ID

try {
    $result = $api_instance->onboard($teamID);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->onboard: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $teamID = teamID_example; # String | Team ID

eval {
    my $result = $api_instance->onboard(teamID => $teamID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->onboard: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
teamID = teamID_example # String | Team ID (default to null)

try:
    # Onboards a user on Boards.
    api_response = api_instance.onboard(teamID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->onboard: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let teamID = teamID_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.onboard(teamID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
teamID*
String
Team ID
Required

Responses


patchBlock

Partially updates a block


/boards/{boardID}/blocks/{blockID}

Usage and SDK Samples

curl -X PATCH \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/boards/{boardID}/blocks/{blockID}?disable_notify=" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID
        String blockID = blockID_example; // String | ID of block to patch
        Object body = Object; // Object | 
        oas_any_type_not_mapped disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk patching)

        try {
            apiInstance.patchBlock(boardID, blockID, body, disableNotify);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#patchBlock");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID
        String blockID = blockID_example; // String | ID of block to patch
        Object body = Object; // Object | 
        oas_any_type_not_mapped disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk patching)

        try {
            apiInstance.patchBlock(boardID, blockID, body, disableNotify);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#patchBlock");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *boardID = boardID_example; // Board ID (default to null)
String *blockID = blockID_example; // ID of block to patch (default to null)
Object *body = Object; // 
oas_any_type_not_mapped *disableNotify = ; // Disables notifications (for bulk patching) (optional) (default to null)

[apiInstance patchBlockWith:boardID
    blockID:blockID
    body:body
    disableNotify:disableNotify
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var boardID = boardID_example; // {String} Board ID
var blockID = blockID_example; // {String} ID of block to patch
var body = Object; // {Object} 
var opts = {
  'disableNotify':  // {oas_any_type_not_mapped} Disables notifications (for bulk patching)
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.patchBlock(boardID, blockID, body, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class patchBlockExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var boardID = boardID_example;  // String | Board ID (default to null)
            var blockID = blockID_example;  // String | ID of block to patch (default to null)
            var body = Object;  // Object | 
            var disableNotify = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | Disables notifications (for bulk patching) (optional)  (default to null)

            try {
                apiInstance.patchBlock(boardID, blockID, body, disableNotify);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.patchBlock: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$boardID = boardID_example; // String | Board ID
$blockID = blockID_example; // String | ID of block to patch
$body = Object; // Object | 
$disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk patching)

try {
    $api_instance->patchBlock($boardID, $blockID, $body, $disableNotify);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->patchBlock: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $boardID = boardID_example; # String | Board ID
my $blockID = blockID_example; # String | ID of block to patch
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 
my $disableNotify = ; # oas_any_type_not_mapped | Disables notifications (for bulk patching)

eval {
    $api_instance->patchBlock(boardID => $boardID, blockID => $blockID, body => $body, disableNotify => $disableNotify);
};
if ($@) {
    warn "Exception when calling DefaultApi->patchBlock: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
boardID = boardID_example # String | Board ID (default to null)
blockID = blockID_example # String | ID of block to patch (default to null)
body = Object # Object | 
disableNotify =  # oas_any_type_not_mapped | Disables notifications (for bulk patching) (optional) (default to null)

try:
    api_instance.patch_block(boardID, blockID, body, disableNotify=disableNotify)
except ApiException as e:
    print("Exception when calling DefaultApi->patchBlock: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let boardID = boardID_example; // String
    let blockID = blockID_example; // String
    let body = Object; // Object
    let disableNotify = ; // oas_any_type_not_mapped

    let mut context = DefaultApi::Context::default();
    let result = client.patchBlock(boardID, blockID, body, disableNotify, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
boardID*
String
Board ID
Required
blockID*
String
ID of block to patch
Required
Body parameters
Name Description
body *

block patch to apply

Query parameters
Name Description
disable_notify
oas_any_type_not_mapped
Disables notifications (for bulk patching)

Responses


patchBlocks

Partially updates batch of blocks


/boards/{boardID}/blocks/

Usage and SDK Samples

curl -X PATCH \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/boards/{boardID}/blocks/?disable_notify=" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Workspace ID
        Object body = Object; // Object | 
        oas_any_type_not_mapped disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk patching)

        try {
            apiInstance.patchBlocks(boardID, body, disableNotify);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#patchBlocks");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Workspace ID
        Object body = Object; // Object | 
        oas_any_type_not_mapped disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk patching)

        try {
            apiInstance.patchBlocks(boardID, body, disableNotify);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#patchBlocks");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *boardID = boardID_example; // Workspace ID (default to null)
Object *body = Object; // 
oas_any_type_not_mapped *disableNotify = ; // Disables notifications (for bulk patching) (optional) (default to null)

[apiInstance patchBlocksWith:boardID
    body:body
    disableNotify:disableNotify
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var boardID = boardID_example; // {String} Workspace ID
var body = Object; // {Object} 
var opts = {
  'disableNotify':  // {oas_any_type_not_mapped} Disables notifications (for bulk patching)
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.patchBlocks(boardID, body, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class patchBlocksExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var boardID = boardID_example;  // String | Workspace ID (default to null)
            var body = Object;  // Object | 
            var disableNotify = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | Disables notifications (for bulk patching) (optional)  (default to null)

            try {
                apiInstance.patchBlocks(boardID, body, disableNotify);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.patchBlocks: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$boardID = boardID_example; // String | Workspace ID
$body = Object; // Object | 
$disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk patching)

try {
    $api_instance->patchBlocks($boardID, $body, $disableNotify);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->patchBlocks: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $boardID = boardID_example; # String | Workspace ID
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 
my $disableNotify = ; # oas_any_type_not_mapped | Disables notifications (for bulk patching)

eval {
    $api_instance->patchBlocks(boardID => $boardID, body => $body, disableNotify => $disableNotify);
};
if ($@) {
    warn "Exception when calling DefaultApi->patchBlocks: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
boardID = boardID_example # String | Workspace ID (default to null)
body = Object # Object | 
disableNotify =  # oas_any_type_not_mapped | Disables notifications (for bulk patching) (optional) (default to null)

try:
    api_instance.patch_blocks(boardID, body, disableNotify=disableNotify)
except ApiException as e:
    print("Exception when calling DefaultApi->patchBlocks: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let boardID = boardID_example; // String
    let body = Object; // Object
    let disableNotify = ; // oas_any_type_not_mapped

    let mut context = DefaultApi::Context::default();
    let result = client.patchBlocks(boardID, body, disableNotify, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
boardID*
String
Workspace ID
Required
Body parameters
Name Description
body *

block Ids and block patches to apply

Query parameters
Name Description
disable_notify
oas_any_type_not_mapped
Disables notifications (for bulk patching)

Responses


patchBoard

Partially updates a board


/boards/{boardID}

Usage and SDK Samples

curl -X PATCH \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/boards/{boardID}" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.patchBoard(boardID, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#patchBoard");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.patchBoard(boardID, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#patchBoard");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *boardID = boardID_example; // Board ID (default to null)
Object *body = Object; // 

[apiInstance patchBoardWith:boardID
    body:body
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var boardID = boardID_example; // {String} Board ID
var body = Object; // {Object} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.patchBoard(boardID, body, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class patchBoardExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var boardID = boardID_example;  // String | Board ID (default to null)
            var body = Object;  // Object | 

            try {
                Object result = apiInstance.patchBoard(boardID, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.patchBoard: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$boardID = boardID_example; // String | Board ID
$body = Object; // Object | 

try {
    $result = $api_instance->patchBoard($boardID, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->patchBoard: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $boardID = boardID_example; # String | Board ID
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    my $result = $api_instance->patchBoard(boardID => $boardID, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->patchBoard: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
boardID = boardID_example # String | Board ID (default to null)
body = Object # Object | 

try:
    api_response = api_instance.patch_board(boardID, body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->patchBoard: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let boardID = boardID_example; // String
    let body = Object; // Object

    let mut context = DefaultApi::Context::default();
    let result = client.patchBoard(boardID, body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
boardID*
String
Board ID
Required
Body parameters
Name Description
body *

board patch to apply

Responses


patchBoardsAndBlocks

Patches a set of related boards and blocks


/boards-and-blocks

Usage and SDK Samples

curl -X PATCH \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/boards-and-blocks" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.patchBoardsAndBlocks(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#patchBoardsAndBlocks");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.patchBoardsAndBlocks(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#patchBoardsAndBlocks");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
Object *body = Object; // 

[apiInstance patchBoardsAndBlocksWith:body
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var body = Object; // {Object} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.patchBoardsAndBlocks(body, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class patchBoardsAndBlocksExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var body = Object;  // Object | 

            try {
                Object result = apiInstance.patchBoardsAndBlocks(body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.patchBoardsAndBlocks: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$body = Object; // Object | 

try {
    $result = $api_instance->patchBoardsAndBlocks($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->patchBoardsAndBlocks: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    my $result = $api_instance->patchBoardsAndBlocks(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->patchBoardsAndBlocks: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
body = Object # Object | 

try:
    api_response = api_instance.patch_boards_and_blocks(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->patchBoardsAndBlocks: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let body = Object; // Object

    let mut context = DefaultApi::Context::default();
    let result = client.patchBoardsAndBlocks(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body *

the patches for the boards and blocks

Responses


patchCard

Patches the specified card.


/cards/{cardID}/cards

Usage and SDK Samples

curl -X PATCH \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/cards/{cardID}/cards?disable_notify=" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String cardID = cardID_example; // String | Card ID
        Object body = Object; // Object | 
        oas_any_type_not_mapped disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk data patching)

        try {
            Object result = apiInstance.patchCard(cardID, body, disableNotify);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#patchCard");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String cardID = cardID_example; // String | Card ID
        Object body = Object; // Object | 
        oas_any_type_not_mapped disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk data patching)

        try {
            Object result = apiInstance.patchCard(cardID, body, disableNotify);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#patchCard");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *cardID = cardID_example; // Card ID (default to null)
Object *body = Object; // 
oas_any_type_not_mapped *disableNotify = ; // Disables notifications (for bulk data patching) (optional) (default to null)

// Patches the specified card.
[apiInstance patchCardWith:cardID
    body:body
    disableNotify:disableNotify
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var cardID = cardID_example; // {String} Card ID
var body = Object; // {Object} 
var opts = {
  'disableNotify':  // {oas_any_type_not_mapped} Disables notifications (for bulk data patching)
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.patchCard(cardID, body, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class patchCardExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var cardID = cardID_example;  // String | Card ID (default to null)
            var body = Object;  // Object | 
            var disableNotify = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | Disables notifications (for bulk data patching) (optional)  (default to null)

            try {
                // Patches the specified card.
                Object result = apiInstance.patchCard(cardID, body, disableNotify);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.patchCard: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$cardID = cardID_example; // String | Card ID
$body = Object; // Object | 
$disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk data patching)

try {
    $result = $api_instance->patchCard($cardID, $body, $disableNotify);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->patchCard: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $cardID = cardID_example; # String | Card ID
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 
my $disableNotify = ; # oas_any_type_not_mapped | Disables notifications (for bulk data patching)

eval {
    my $result = $api_instance->patchCard(cardID => $cardID, body => $body, disableNotify => $disableNotify);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->patchCard: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
cardID = cardID_example # String | Card ID (default to null)
body = Object # Object | 
disableNotify =  # oas_any_type_not_mapped | Disables notifications (for bulk data patching) (optional) (default to null)

try:
    # Patches the specified card.
    api_response = api_instance.patch_card(cardID, body, disableNotify=disableNotify)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->patchCard: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let cardID = cardID_example; // String
    let body = Object; // Object
    let disableNotify = ; // oas_any_type_not_mapped

    let mut context = DefaultApi::Context::default();
    let result = client.patchCard(cardID, body, disableNotify, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
cardID*
String
Card ID
Required
Body parameters
Name Description
body *

the card patch

Query parameters
Name Description
disable_notify
oas_any_type_not_mapped
Disables notifications (for bulk data patching)

Responses


ping

Responds with server metadata if the web service is running.


/ping

Usage and SDK Samples

curl -X GET \
 "http://localhost/api/v2/ping"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();

        try {
            apiInstance.ping();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#ping");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();

        try {
            apiInstance.ping();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#ping");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Responds with server metadata if the web service is running.
[apiInstance pingWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ping(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class pingExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                // Responds with server metadata if the web service is running.
                apiInstance.ping();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.ping: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $api_instance->ping();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->ping: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval {
    $api_instance->ping();
};
if ($@) {
    warn "Exception when calling DefaultApi->ping: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try:
    # Responds with server metadata if the web service is running.
    api_instance.ping()
except ApiException as e:
    print("Exception when calling DefaultApi->ping: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

    let mut context = DefaultApi::Context::default();
    let result = client.ping(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


postSharing

Sets sharing information for a board


/boards/{boardID}/sharing

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/boards/{boardID}/sharing" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID
        Object body = Object; // Object | 

        try {
            apiInstance.postSharing(boardID, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#postSharing");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID
        Object body = Object; // Object | 

        try {
            apiInstance.postSharing(boardID, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#postSharing");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *boardID = boardID_example; // Board ID (default to null)
Object *body = Object; // 

[apiInstance postSharingWith:boardID
    body:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var boardID = boardID_example; // {String} Board ID
var body = Object; // {Object} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.postSharing(boardID, body, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class postSharingExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var boardID = boardID_example;  // String | Board ID (default to null)
            var body = Object;  // Object | 

            try {
                apiInstance.postSharing(boardID, body);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.postSharing: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$boardID = boardID_example; // String | Board ID
$body = Object; // Object | 

try {
    $api_instance->postSharing($boardID, $body);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->postSharing: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $boardID = boardID_example; # String | Board ID
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->postSharing(boardID => $boardID, body => $body);
};
if ($@) {
    warn "Exception when calling DefaultApi->postSharing: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
boardID = boardID_example # String | Board ID (default to null)
body = Object # Object | 

try:
    api_instance.post_sharing(boardID, body)
except ApiException as e:
    print("Exception when calling DefaultApi->postSharing: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let boardID = boardID_example; // String
    let body = Object; // Object

    let mut context = DefaultApi::Context::default();
    let result = client.postSharing(boardID, body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
boardID*
String
Board ID
Required
Body parameters
Name Description
body *

sharing information for a root block

Responses


regenerateSignupToken

Regenerates the signup token for the root team


/teams/{teamID}/regenerate_signup_token

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/teams/{teamID}/regenerate_signup_token"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID

        try {
            apiInstance.regenerateSignupToken(teamID);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#regenerateSignupToken");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID

        try {
            apiInstance.regenerateSignupToken(teamID);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#regenerateSignupToken");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *teamID = teamID_example; // Team ID (default to null)

[apiInstance regenerateSignupTokenWith:teamID
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var teamID = teamID_example; // {String} Team ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.regenerateSignupToken(teamID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class regenerateSignupTokenExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var teamID = teamID_example;  // String | Team ID (default to null)

            try {
                apiInstance.regenerateSignupToken(teamID);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.regenerateSignupToken: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$teamID = teamID_example; // String | Team ID

try {
    $api_instance->regenerateSignupToken($teamID);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->regenerateSignupToken: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $teamID = teamID_example; # String | Team ID

eval {
    $api_instance->regenerateSignupToken(teamID => $teamID);
};
if ($@) {
    warn "Exception when calling DefaultApi->regenerateSignupToken: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
teamID = teamID_example # String | Team ID (default to null)

try:
    api_instance.regenerate_signup_token(teamID)
except ApiException as e:
    print("Exception when calling DefaultApi->regenerateSignupToken: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let teamID = teamID_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.regenerateSignupToken(teamID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
teamID*
String
Team ID
Required

Responses


register

Register new user


/register

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/register" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        Object body = Object; // Object | 

        try {
            apiInstance.register(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#register");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Object body = Object; // Object | 

        try {
            apiInstance.register(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#register");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
Object *body = Object; // 

[apiInstance registerWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var body = Object; // {Object} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.register(body, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class registerExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var body = Object;  // Object | 

            try {
                apiInstance.register(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.register: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$body = Object; // Object | 

try {
    $api_instance->register($body);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->register: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->register(body => $body);
};
if ($@) {
    warn "Exception when calling DefaultApi->register: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
body = Object # Object | 

try:
    api_instance.register(body)
except ApiException as e:
    print("Exception when calling DefaultApi->register: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let body = Object; // Object

    let mut context = DefaultApi::Context::default();
    let result = client.register(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body *

Register request

Responses


searchAllBoards

Returns the boards that match with a search term


/boards/search

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/boards/search?q=q_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String q = q_example; // String | The search term. Must have at least one character

        try {
            array[Object] result = apiInstance.searchAllBoards(q);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#searchAllBoards");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String q = q_example; // String | The search term. Must have at least one character

        try {
            array[Object] result = apiInstance.searchAllBoards(q);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#searchAllBoards");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *q = q_example; // The search term. Must have at least one character (default to null)

[apiInstance searchAllBoardsWith:q
              completionHandler: ^(array[Object] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var q = q_example; // {String} The search term. Must have at least one character

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.searchAllBoards(q, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class searchAllBoardsExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var q = q_example;  // String | The search term. Must have at least one character (default to null)

            try {
                array[Object] result = apiInstance.searchAllBoards(q);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.searchAllBoards: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$q = q_example; // String | The search term. Must have at least one character

try {
    $result = $api_instance->searchAllBoards($q);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->searchAllBoards: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $q = q_example; # String | The search term. Must have at least one character

eval {
    my $result = $api_instance->searchAllBoards(q => $q);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->searchAllBoards: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
q = q_example # String | The search term. Must have at least one character (default to null)

try:
    api_response = api_instance.search_all_boards(q)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->searchAllBoards: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let q = q_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.searchAllBoards(q, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
q*
String
The search term. Must have at least one character
Required

Responses


searchBoards

Returns the boards that match with a search term in the team


/teams/{teamID}/boards/search

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/teams/{teamID}/boards/search?q=q_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID
        String q = q_example; // String | The search term. Must have at least one character

        try {
            array[Object] result = apiInstance.searchBoards(teamID, q);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#searchBoards");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID
        String q = q_example; // String | The search term. Must have at least one character

        try {
            array[Object] result = apiInstance.searchBoards(teamID, q);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#searchBoards");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *teamID = teamID_example; // Team ID (default to null)
String *q = q_example; // The search term. Must have at least one character (default to null)

[apiInstance searchBoardsWith:teamID
    q:q
              completionHandler: ^(array[Object] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var teamID = teamID_example; // {String} Team ID
var q = q_example; // {String} The search term. Must have at least one character

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.searchBoards(teamID, q, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class searchBoardsExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var teamID = teamID_example;  // String | Team ID (default to null)
            var q = q_example;  // String | The search term. Must have at least one character (default to null)

            try {
                array[Object] result = apiInstance.searchBoards(teamID, q);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.searchBoards: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$teamID = teamID_example; // String | Team ID
$q = q_example; // String | The search term. Must have at least one character

try {
    $result = $api_instance->searchBoards($teamID, $q);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->searchBoards: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $teamID = teamID_example; # String | Team ID
my $q = q_example; # String | The search term. Must have at least one character

eval {
    my $result = $api_instance->searchBoards(teamID => $teamID, q => $q);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->searchBoards: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
teamID = teamID_example # String | Team ID (default to null)
q = q_example # String | The search term. Must have at least one character (default to null)

try:
    api_response = api_instance.search_boards(teamID, q)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->searchBoards: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let teamID = teamID_example; // String
    let q = q_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.searchBoards(teamID, q, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
teamID*
String
Team ID
Required
Query parameters
Name Description
q*
String
The search term. Must have at least one character
Required

Responses


searchLinkableBoards

Returns the boards that match with a search term in the team and the user has permission to manage members


/teams/{teamID}/boards/search/linkable

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/teams/{teamID}/boards/search/linkable?q=q_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID
        String q = q_example; // String | The search term. Must have at least one character

        try {
            array[Object] result = apiInstance.searchLinkableBoards(teamID, q);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#searchLinkableBoards");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID
        String q = q_example; // String | The search term. Must have at least one character

        try {
            array[Object] result = apiInstance.searchLinkableBoards(teamID, q);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#searchLinkableBoards");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *teamID = teamID_example; // Team ID (default to null)
String *q = q_example; // The search term. Must have at least one character (default to null)

[apiInstance searchLinkableBoardsWith:teamID
    q:q
              completionHandler: ^(array[Object] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var teamID = teamID_example; // {String} Team ID
var q = q_example; // {String} The search term. Must have at least one character

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.searchLinkableBoards(teamID, q, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class searchLinkableBoardsExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var teamID = teamID_example;  // String | Team ID (default to null)
            var q = q_example;  // String | The search term. Must have at least one character (default to null)

            try {
                array[Object] result = apiInstance.searchLinkableBoards(teamID, q);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.searchLinkableBoards: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$teamID = teamID_example; // String | Team ID
$q = q_example; // String | The search term. Must have at least one character

try {
    $result = $api_instance->searchLinkableBoards($teamID, $q);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->searchLinkableBoards: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $teamID = teamID_example; # String | Team ID
my $q = q_example; # String | The search term. Must have at least one character

eval {
    my $result = $api_instance->searchLinkableBoards(teamID => $teamID, q => $q);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->searchLinkableBoards: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
teamID = teamID_example # String | Team ID (default to null)
q = q_example # String | The search term. Must have at least one character (default to null)

try:
    api_response = api_instance.search_linkable_boards(teamID, q)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->searchLinkableBoards: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let teamID = teamID_example; // String
    let q = q_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.searchLinkableBoards(teamID, q, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
teamID*
String
Team ID
Required
Query parameters
Name Description
q*
String
The search term. Must have at least one character
Required

Responses


searchMyChannels

Returns the user available channels


/teams/{teamID}/channels

Usage and SDK Samples

curl -X GET \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/teams/{teamID}/channels?search=search_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID
        String search = search_example; // String | string to filter channels list

        try {
            array[Channel] result = apiInstance.searchMyChannels(teamID, search);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#searchMyChannels");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID
        String search = search_example; // String | string to filter channels list

        try {
            array[Channel] result = apiInstance.searchMyChannels(teamID, search);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#searchMyChannels");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *teamID = teamID_example; // Team ID (default to null)
String *search = search_example; // string to filter channels list (optional) (default to null)

[apiInstance searchMyChannelsWith:teamID
    search:search
              completionHandler: ^(array[Channel] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var teamID = teamID_example; // {String} Team ID
var opts = {
  'search': search_example // {String} string to filter channels list
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.searchMyChannels(teamID, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class searchMyChannelsExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var teamID = teamID_example;  // String | Team ID (default to null)
            var search = search_example;  // String | string to filter channels list (optional)  (default to null)

            try {
                array[Channel] result = apiInstance.searchMyChannels(teamID, search);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.searchMyChannels: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$teamID = teamID_example; // String | Team ID
$search = search_example; // String | string to filter channels list

try {
    $result = $api_instance->searchMyChannels($teamID, $search);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->searchMyChannels: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $teamID = teamID_example; # String | Team ID
my $search = search_example; # String | string to filter channels list

eval {
    my $result = $api_instance->searchMyChannels(teamID => $teamID, search => $search);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->searchMyChannels: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
teamID = teamID_example # String | Team ID (default to null)
search = search_example # String | string to filter channels list (optional) (default to null)

try:
    api_response = api_instance.search_my_channels(teamID, search=search)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->searchMyChannels: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let teamID = teamID_example; // String
    let search = search_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.searchMyChannels(teamID, search, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
teamID*
String
Team ID
Required
Query parameters
Name Description
search

Responses


undeleteBlock

Undeletes a block


/boards/{boardID}/blocks/{blockID}/undelete

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/boards/{boardID}/blocks/{blockID}/undelete"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID
        String blockID = blockID_example; // String | ID of block to undelete

        try {
            Object result = apiInstance.undeleteBlock(boardID, blockID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#undeleteBlock");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID
        String blockID = blockID_example; // String | ID of block to undelete

        try {
            Object result = apiInstance.undeleteBlock(boardID, blockID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#undeleteBlock");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *boardID = boardID_example; // Board ID (default to null)
String *blockID = blockID_example; // ID of block to undelete (default to null)

[apiInstance undeleteBlockWith:boardID
    blockID:blockID
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var boardID = boardID_example; // {String} Board ID
var blockID = blockID_example; // {String} ID of block to undelete

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.undeleteBlock(boardID, blockID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class undeleteBlockExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var boardID = boardID_example;  // String | Board ID (default to null)
            var blockID = blockID_example;  // String | ID of block to undelete (default to null)

            try {
                Object result = apiInstance.undeleteBlock(boardID, blockID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.undeleteBlock: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$boardID = boardID_example; // String | Board ID
$blockID = blockID_example; // String | ID of block to undelete

try {
    $result = $api_instance->undeleteBlock($boardID, $blockID);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->undeleteBlock: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $boardID = boardID_example; # String | Board ID
my $blockID = blockID_example; # String | ID of block to undelete

eval {
    my $result = $api_instance->undeleteBlock(boardID => $boardID, blockID => $blockID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->undeleteBlock: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
boardID = boardID_example # String | Board ID (default to null)
blockID = blockID_example # String | ID of block to undelete (default to null)

try:
    api_response = api_instance.undelete_block(boardID, blockID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->undeleteBlock: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let boardID = boardID_example; // String
    let blockID = blockID_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.undeleteBlock(boardID, blockID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
boardID*
String
Board ID
Required
blockID*
String
ID of block to undelete
Required

Responses


undeleteBoard

Undeletes a board


/boards/{boardID}/undelete

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/boards/{boardID}/undelete"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | ID of board to undelete

        try {
            apiInstance.undeleteBoard(boardID);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#undeleteBoard");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | ID of board to undelete

        try {
            apiInstance.undeleteBoard(boardID);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#undeleteBoard");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *boardID = boardID_example; // ID of board to undelete (default to null)

[apiInstance undeleteBoardWith:boardID
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var boardID = boardID_example; // {String} ID of board to undelete

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.undeleteBoard(boardID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class undeleteBoardExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var boardID = boardID_example;  // String | ID of board to undelete (default to null)

            try {
                apiInstance.undeleteBoard(boardID);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.undeleteBoard: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$boardID = boardID_example; // String | ID of board to undelete

try {
    $api_instance->undeleteBoard($boardID);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->undeleteBoard: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $boardID = boardID_example; # String | ID of board to undelete

eval {
    $api_instance->undeleteBoard(boardID => $boardID);
};
if ($@) {
    warn "Exception when calling DefaultApi->undeleteBoard: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
boardID = boardID_example # String | ID of board to undelete (default to null)

try:
    api_instance.undelete_board(boardID)
except ApiException as e:
    print("Exception when calling DefaultApi->undeleteBoard: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let boardID = boardID_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.undeleteBoard(boardID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
boardID*
String
ID of board to undelete
Required

Responses


updateBlocks

Insert blocks. The specified IDs will only be used to link blocks with existing ones, the rest will be replaced by server generated IDs


/boards/{boardID}/blocks

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/boards/{boardID}/blocks?disable_notify=" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID
        array[Object] body = ; // array[Object] | 
        oas_any_type_not_mapped disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk inserting)

        try {
            array[Object] result = apiInstance.updateBlocks(boardID, body, disableNotify);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateBlocks");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID
        array[Object] body = ; // array[Object] | 
        oas_any_type_not_mapped disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk inserting)

        try {
            array[Object] result = apiInstance.updateBlocks(boardID, body, disableNotify);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateBlocks");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *boardID = boardID_example; // Board ID (default to null)
array[Object] *body = ; // 
oas_any_type_not_mapped *disableNotify = ; // Disables notifications (for bulk inserting) (optional) (default to null)

[apiInstance updateBlocksWith:boardID
    body:body
    disableNotify:disableNotify
              completionHandler: ^(array[Object] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var boardID = boardID_example; // {String} Board ID
var body = ; // {array[Object]} 
var opts = {
  'disableNotify':  // {oas_any_type_not_mapped} Disables notifications (for bulk inserting)
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateBlocks(boardID, body, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class updateBlocksExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var boardID = boardID_example;  // String | Board ID (default to null)
            var body = new array[Object](); // array[Object] | 
            var disableNotify = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | Disables notifications (for bulk inserting) (optional)  (default to null)

            try {
                array[Object] result = apiInstance.updateBlocks(boardID, body, disableNotify);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.updateBlocks: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$boardID = boardID_example; // String | Board ID
$body = ; // array[Object] | 
$disableNotify = ; // oas_any_type_not_mapped | Disables notifications (for bulk inserting)

try {
    $result = $api_instance->updateBlocks($boardID, $body, $disableNotify);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->updateBlocks: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $boardID = boardID_example; # String | Board ID
my $body = [WWW::OPenAPIClient::Object::array[Object]->new()]; # array[Object] | 
my $disableNotify = ; # oas_any_type_not_mapped | Disables notifications (for bulk inserting)

eval {
    my $result = $api_instance->updateBlocks(boardID => $boardID, body => $body, disableNotify => $disableNotify);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->updateBlocks: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
boardID = boardID_example # String | Board ID (default to null)
body =  # array[Object] | 
disableNotify =  # oas_any_type_not_mapped | Disables notifications (for bulk inserting) (optional) (default to null)

try:
    api_response = api_instance.update_blocks(boardID, body, disableNotify=disableNotify)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->updateBlocks: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let boardID = boardID_example; // String
    let body = ; // array[Object]
    let disableNotify = ; // oas_any_type_not_mapped

    let mut context = DefaultApi::Context::default();
    let result = client.updateBlocks(boardID, body, disableNotify, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
boardID*
String
Board ID
Required
Body parameters
Name Description
body *

array of blocks to insert or update

Query parameters
Name Description
disable_notify
oas_any_type_not_mapped
Disables notifications (for bulk inserting)

Responses


updateCategory

Create a category for boards


/teams/{teamID}/categories/{categoryID}

Usage and SDK Samples

curl -X PUT \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/teams/{teamID}/categories/{categoryID}" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID
        String categoryID = categoryID_example; // String | Category ID
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.updateCategory(teamID, categoryID, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateCategory");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID
        String categoryID = categoryID_example; // String | Category ID
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.updateCategory(teamID, categoryID, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateCategory");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *teamID = teamID_example; // Team ID (default to null)
String *categoryID = categoryID_example; // Category ID (default to null)
Object *body = Object; // 

[apiInstance updateCategoryWith:teamID
    categoryID:categoryID
    body:body
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var teamID = teamID_example; // {String} Team ID
var categoryID = categoryID_example; // {String} Category ID
var body = Object; // {Object} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateCategory(teamID, categoryID, body, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class updateCategoryExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var teamID = teamID_example;  // String | Team ID (default to null)
            var categoryID = categoryID_example;  // String | Category ID (default to null)
            var body = Object;  // Object | 

            try {
                Object result = apiInstance.updateCategory(teamID, categoryID, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.updateCategory: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$teamID = teamID_example; // String | Team ID
$categoryID = categoryID_example; // String | Category ID
$body = Object; // Object | 

try {
    $result = $api_instance->updateCategory($teamID, $categoryID, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->updateCategory: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $teamID = teamID_example; # String | Team ID
my $categoryID = categoryID_example; # String | Category ID
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    my $result = $api_instance->updateCategory(teamID => $teamID, categoryID => $categoryID, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->updateCategory: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
teamID = teamID_example # String | Team ID (default to null)
categoryID = categoryID_example # String | Category ID (default to null)
body = Object # Object | 

try:
    api_response = api_instance.update_category(teamID, categoryID, body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->updateCategory: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let teamID = teamID_example; // String
    let categoryID = categoryID_example; // String
    let body = Object; // Object

    let mut context = DefaultApi::Context::default();
    let result = client.updateCategory(teamID, categoryID, body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
teamID*
String
Team ID
Required
categoryID*
String
Category ID
Required
Body parameters
Name Description
body *

category to update

Responses


updateCategoryBoard

Set the category of a board


/teams/{teamID}/categories/{categoryID}/boards/{boardID}

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 "http://localhost/api/v2/teams/{teamID}/categories/{categoryID}/boards/{boardID}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID
        String categoryID = categoryID_example; // String | Category ID
        String boardID = boardID_example; // String | Board ID

        try {
            apiInstance.updateCategoryBoard(teamID, categoryID, boardID);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateCategoryBoard");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | Team ID
        String categoryID = categoryID_example; // String | Category ID
        String boardID = boardID_example; // String | Board ID

        try {
            apiInstance.updateCategoryBoard(teamID, categoryID, boardID);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateCategoryBoard");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *teamID = teamID_example; // Team ID (default to null)
String *categoryID = categoryID_example; // Category ID (default to null)
String *boardID = boardID_example; // Board ID (default to null)

[apiInstance updateCategoryBoardWith:teamID
    categoryID:categoryID
    boardID:boardID
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var teamID = teamID_example; // {String} Team ID
var categoryID = categoryID_example; // {String} Category ID
var boardID = boardID_example; // {String} Board ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateCategoryBoard(teamID, categoryID, boardID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class updateCategoryBoardExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var teamID = teamID_example;  // String | Team ID (default to null)
            var categoryID = categoryID_example;  // String | Category ID (default to null)
            var boardID = boardID_example;  // String | Board ID (default to null)

            try {
                apiInstance.updateCategoryBoard(teamID, categoryID, boardID);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.updateCategoryBoard: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$teamID = teamID_example; // String | Team ID
$categoryID = categoryID_example; // String | Category ID
$boardID = boardID_example; // String | Board ID

try {
    $api_instance->updateCategoryBoard($teamID, $categoryID, $boardID);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->updateCategoryBoard: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $teamID = teamID_example; # String | Team ID
my $categoryID = categoryID_example; # String | Category ID
my $boardID = boardID_example; # String | Board ID

eval {
    $api_instance->updateCategoryBoard(teamID => $teamID, categoryID => $categoryID, boardID => $boardID);
};
if ($@) {
    warn "Exception when calling DefaultApi->updateCategoryBoard: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
teamID = teamID_example # String | Team ID (default to null)
categoryID = categoryID_example # String | Category ID (default to null)
boardID = boardID_example # String | Board ID (default to null)

try:
    api_instance.update_category_board(teamID, categoryID, boardID)
except ApiException as e:
    print("Exception when calling DefaultApi->updateCategoryBoard: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let teamID = teamID_example; // String
    let categoryID = categoryID_example; // String
    let boardID = boardID_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.updateCategoryBoard(teamID, categoryID, boardID, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
teamID*
String
Team ID
Required
categoryID*
String
Category ID
Required
boardID*
String
Board ID
Required

Responses


updateMember

Updates a board member


/boards/{boardID}/members/{userID}

Usage and SDK Samples

curl -X PUT \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/boards/{boardID}/members/{userID}" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID
        String userID = userID_example; // String | User ID
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.updateMember(boardID, userID, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateMember");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String boardID = boardID_example; // String | Board ID
        String userID = userID_example; // String | User ID
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.updateMember(boardID, userID, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateMember");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *boardID = boardID_example; // Board ID (default to null)
String *userID = userID_example; // User ID (default to null)
Object *body = Object; // 

[apiInstance updateMemberWith:boardID
    userID:userID
    body:body
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var boardID = boardID_example; // {String} Board ID
var userID = userID_example; // {String} User ID
var body = Object; // {Object} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateMember(boardID, userID, body, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class updateMemberExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var boardID = boardID_example;  // String | Board ID (default to null)
            var userID = userID_example;  // String | User ID (default to null)
            var body = Object;  // Object | 

            try {
                Object result = apiInstance.updateMember(boardID, userID, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.updateMember: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$boardID = boardID_example; // String | Board ID
$userID = userID_example; // String | User ID
$body = Object; // Object | 

try {
    $result = $api_instance->updateMember($boardID, $userID, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->updateMember: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $boardID = boardID_example; # String | Board ID
my $userID = userID_example; # String | User ID
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    my $result = $api_instance->updateMember(boardID => $boardID, userID => $userID, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->updateMember: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
boardID = boardID_example # String | Board ID (default to null)
userID = userID_example # String | User ID (default to null)
body = Object # Object | 

try:
    api_response = api_instance.update_member(boardID, userID, body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->updateMember: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let boardID = boardID_example; // String
    let userID = userID_example; // String
    let body = Object; // Object

    let mut context = DefaultApi::Context::default();
    let result = client.updateMember(boardID, userID, body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
boardID*
String
Board ID
Required
userID*
String
User ID
Required
Body parameters
Name Description
body *

membership to replace the current one with

Responses


updateUserConfig

Updates user config


/users/{userID}/config

Usage and SDK Samples

curl -X PATCH \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v2/users/{userID}/config" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String userID = userID_example; // String | User ID
        Object body = Object; // Object | 

        try {
            apiInstance.updateUserConfig(userID, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateUserConfig");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String userID = userID_example; // String | User ID
        Object body = Object; // Object | 

        try {
            apiInstance.updateUserConfig(userID, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateUserConfig");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *userID = userID_example; // User ID (default to null)
Object *body = Object; // 

[apiInstance updateUserConfigWith:userID
    body:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var userID = userID_example; // {String} User ID
var body = Object; // {Object} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateUserConfig(userID, body, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class updateUserConfigExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var userID = userID_example;  // String | User ID (default to null)
            var body = Object;  // Object | 

            try {
                apiInstance.updateUserConfig(userID, body);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.updateUserConfig: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$userID = userID_example; // String | User ID
$body = Object; // Object | 

try {
    $api_instance->updateUserConfig($userID, $body);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->updateUserConfig: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $userID = userID_example; # String | User ID
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->updateUserConfig(userID => $userID, body => $body);
};
if ($@) {
    warn "Exception when calling DefaultApi->updateUserConfig: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
userID = userID_example # String | User ID (default to null)
body = Object # Object | 

try:
    api_instance.update_user_config(userID, body)
except ApiException as e:
    print("Exception when calling DefaultApi->updateUserConfig: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let userID = userID_example; // String
    let body = Object; // Object

    let mut context = DefaultApi::Context::default();
    let result = client.updateUserConfig(userID, body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
userID*
String
User ID
Required
Body parameters
Name Description
body *

User config patch to apply

Responses


uploadFile

Upload a binary file, attached to a root block


/teams/{teamID}/boards/{boardID}/files

Usage and SDK Samples

curl -X POST \
-H "Authorization: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: multipart/form-data" \
 "http://localhost/api/v2/teams/{teamID}/boards/{boardID}/files"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: BearerAuth
        ApiKeyAuth BearerAuth = (ApiKeyAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //BearerAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | ID of the team
        String boardID = boardID_example; // String | Board ID
        File uploaded file = BINARY_DATA_HERE; // File | The file to upload

        try {
            Object result = apiInstance.uploadFile(teamID, boardID, uploaded file);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#uploadFile");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String teamID = teamID_example; // String | ID of the team
        String boardID = boardID_example; // String | Board ID
        File uploaded file = BINARY_DATA_HERE; // File | The file to upload

        try {
            Object result = apiInstance.uploadFile(teamID, boardID, uploaded file);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#uploadFile");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: BearerAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *teamID = teamID_example; // ID of the team (default to null)
String *boardID = boardID_example; // Board ID (default to null)
File *uploaded file = BINARY_DATA_HERE; // The file to upload (optional) (default to null)

[apiInstance uploadFileWith:teamID
    boardID:boardID
    uploaded file:uploaded file
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var FocalboardServer = require('focalboard_server');
var defaultClient = FocalboardServer.ApiClient.instance;

// Configure API key authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//BearerAuth.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new FocalboardServer.DefaultApi()
var teamID = teamID_example; // {String} ID of the team
var boardID = boardID_example; // {String} Board ID
var opts = {
  'uploaded file': BINARY_DATA_HERE // {File} The file to upload
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.uploadFile(teamID, boardID, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class uploadFileExample
    {
        public void main()
        {
            // Configure API key authorization: BearerAuth
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var teamID = teamID_example;  // String | ID of the team (default to null)
            var boardID = boardID_example;  // String | Board ID (default to null)
            var uploaded file = BINARY_DATA_HERE;  // File | The file to upload (optional)  (default to null)

            try {
                Object result = apiInstance.uploadFile(teamID, boardID, uploaded file);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.uploadFile: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$teamID = teamID_example; // String | ID of the team
$boardID = boardID_example; // String | Board ID
$uploaded file = BINARY_DATA_HERE; // File | The file to upload

try {
    $result = $api_instance->uploadFile($teamID, $boardID, $uploaded file);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->uploadFile: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $teamID = teamID_example; # String | ID of the team
my $boardID = boardID_example; # String | Board ID
my $uploaded file = BINARY_DATA_HERE; # File | The file to upload

eval {
    my $result = $api_instance->uploadFile(teamID => $teamID, boardID => $boardID, uploaded file => $uploaded file);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->uploadFile: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: BearerAuth
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
teamID = teamID_example # String | ID of the team (default to null)
boardID = boardID_example # String | Board ID (default to null)
uploaded file = BINARY_DATA_HERE # File | The file to upload (optional) (default to null)

try:
    api_response = api_instance.upload_file(teamID, boardID, uploaded file=uploaded file)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->uploadFile: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let teamID = teamID_example; // String
    let boardID = boardID_example; // String
    let uploaded file = BINARY_DATA_HERE; // File

    let mut context = DefaultApi::Context::default();
    let result = client.uploadFile(teamID, boardID, uploaded file, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
teamID*
String
ID of the team
Required
boardID*
String
Board ID
Required
Form parameters
Name Description
uploaded file
File (binary)
The file to upload

Responses