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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        AdminApi apiInstance = new AdminApi();
        String room = galactic; // String | Name of room to use.

        try {
            putRoom_200_response result = apiInstance.assignGM(room);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#assignGM");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String room = new String(); // String | Name of room to use.

try {
    final result = await api_instance.assignGM(room);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->assignGM: $e\n');
}

import org.openapitools.client.api.AdminApi;

public class AdminApiExample {
    public static void main(String[] args) {
        AdminApi apiInstance = new AdminApi();
        String room = galactic; // String | Name of room to use.

        try {
            putRoom_200_response result = apiInstance.assignGM(room);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#assignGM");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
AdminApi *apiInstance = [[AdminApi alloc] init];
String *room = galactic; // Name of room to use. (default to null)

// Randomly assign GM
[apiInstance assignGMWith:room
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

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

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.AdminApi()
var room = galactic; // {String} Name of room to use.

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

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

namespace Example
{
    public class assignGMExample
    {
        public void main()
        {
            // Configure API key authorization: UserAuth
            Configuration.Default.ApiKey.Add("X-Assassin-User", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-Assassin-User", "Bearer");
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new AdminApi();
            var room = galactic;  // String | Name of room to use. (default to null)

            try {
                // Randomly assign GM
                putRoom_200_response result = apiInstance.assignGM(room);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminApi.assignGM: " + e.Message );
            }
        }
    }
}

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

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminApi();
$room = galactic; // String | Name of room to use.

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

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminApi->new();
my $room = galactic; # String | Name of room to use.

eval {
    my $result = $api_instance->assignGM(room => $room);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminApi->assignGM: $@\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: UserAuth
openapi_client.configuration.api_key['X-Assassin-User'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-Assassin-User'] = 'Bearer'

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.AdminApi()
room = galactic # String | Name of room to use. (default to null)

try:
    # Randomly assign GM
    api_response = api_instance.assign_gm(room)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminApi->assignGM: %s\n" % e)

extern crate AdminApi;

pub fn main() {
    let room = galactic; // String

    let mut context = AdminApi::Context::default();
    let result = client.assignGM(room, &context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.checkWordLists();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->checkWordLists: $e\n');
}

import org.openapitools.client.api.AdminApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

// Check importable wordlists.
[apiInstance checkWordListsWithCompletionHandler: 
              ^(array[ImportableWordList] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

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

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

namespace Example
{
    public class checkWordListsExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Check importable wordlists.
                array[ImportableWordList] result = apiInstance.checkWordLists();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminApi.checkWordLists: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Check importable wordlists.
    api_response = api_instance.check_word_lists()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminApi->checkWordLists: %s\n" % e)

extern crate AdminApi;

pub fn main() {

    let mut context = AdminApi::Context::default();
    let result = client.checkWordLists(&context).wait();

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

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        AdminApi apiInstance = new AdminApi();
        String room = galactic; // String | Name of room to use.
        String name = Vlad; // String | Name of player within a room.

        try {
            putRoom_200_response result = apiInstance.deletePlayer(room, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#deletePlayer");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String room = new String(); // String | Name of room to use.
final String name = new String(); // String | Name of player within a room.

try {
    final result = await api_instance.deletePlayer(room, name);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deletePlayer: $e\n');
}

import org.openapitools.client.api.AdminApi;

public class AdminApiExample {
    public static void main(String[] args) {
        AdminApi apiInstance = new AdminApi();
        String room = galactic; // String | Name of room to use.
        String name = Vlad; // String | Name of player within a room.

        try {
            putRoom_200_response result = apiInstance.deletePlayer(room, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#deletePlayer");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
AdminApi *apiInstance = [[AdminApi alloc] init];
String *room = galactic; // Name of room to use. (default to null)
String *name = Vlad; // Name of player within a room. (default to null)

// Delete player
[apiInstance deletePlayerWith:room
    name:name
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

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

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.AdminApi()
var room = galactic; // {String} Name of room to use.
var name = Vlad; // {String} Name of player within a room.

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

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

namespace Example
{
    public class deletePlayerExample
    {
        public void main()
        {
            // Configure API key authorization: UserAuth
            Configuration.Default.ApiKey.Add("X-Assassin-User", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-Assassin-User", "Bearer");
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new AdminApi();
            var room = galactic;  // String | Name of room to use. (default to null)
            var name = Vlad;  // String | Name of player within a room. (default to null)

            try {
                // Delete player
                putRoom_200_response result = apiInstance.deletePlayer(room, name);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminApi.deletePlayer: " + e.Message );
            }
        }
    }
}

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

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminApi();
$room = galactic; // String | Name of room to use.
$name = Vlad; // String | Name of player within a room.

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

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminApi->new();
my $room = galactic; # String | Name of room to use.
my $name = Vlad; # String | Name of player within a room.

eval {
    my $result = $api_instance->deletePlayer(room => $room, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminApi->deletePlayer: $@\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: UserAuth
openapi_client.configuration.api_key['X-Assassin-User'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-Assassin-User'] = 'Bearer'

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.AdminApi()
room = galactic # String | Name of room to use. (default to null)
name = Vlad # String | Name of player within a room. (default to null)

try:
    # Delete player
    api_response = api_instance.delete_player(room, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminApi->deletePlayer: %s\n" % e)

extern crate AdminApi;

pub fn main() {
    let room = galactic; // String
    let name = Vlad; // String

    let mut context = AdminApi::Context::default();
    let result = client.deletePlayer(room, name, &context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        AdminApi apiInstance = new AdminApi();
        String room = galactic; // String | Name of room to use.

        try {
            putRoom_200_response result = apiInstance.deleteRoom(room);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#deleteRoom");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String room = new String(); // String | Name of room to use.

try {
    final result = await api_instance.deleteRoom(room);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteRoom: $e\n');
}

import org.openapitools.client.api.AdminApi;

public class AdminApiExample {
    public static void main(String[] args) {
        AdminApi apiInstance = new AdminApi();
        String room = galactic; // String | Name of room to use.

        try {
            putRoom_200_response result = apiInstance.deleteRoom(room);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#deleteRoom");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
AdminApi *apiInstance = [[AdminApi alloc] init];
String *room = galactic; // Name of room to use. (default to null)

// Delete room
[apiInstance deleteRoomWith:room
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.AdminApi()
var room = galactic; // {String} Name of room to use.

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

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

namespace Example
{
    public class deleteRoomExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new AdminApi();
            var room = galactic;  // String | Name of room to use. (default to null)

            try {
                // Delete room
                putRoom_200_response result = apiInstance.deleteRoom(room);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminApi.deleteRoom: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminApi();
$room = galactic; // String | Name of room to use.

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminApi->new();
my $room = galactic; # String | Name of room to use.

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

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.AdminApi()
room = galactic # String | Name of room to use. (default to null)

try:
    # Delete room
    api_response = api_instance.delete_room(room)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminApi->deleteRoom: %s\n" % e)

extern crate AdminApi;

pub fn main() {
    let room = galactic; // String

    let mut context = AdminApi::Context::default();
    let result = client.deleteRoom(room, &context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        AdminApi apiInstance = new AdminApi();
        String list = card-poison; // String | Name of word list to use.
        String word = test; // String | Word to add/delete.

        try {
            putRoom_200_response result = apiInstance.deleteWord(list, word);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#deleteWord");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String list = new String(); // String | Name of word list to use.
final String word = new String(); // String | Word to add/delete.

try {
    final result = await api_instance.deleteWord(list, word);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteWord: $e\n');
}

import org.openapitools.client.api.AdminApi;

public class AdminApiExample {
    public static void main(String[] args) {
        AdminApi apiInstance = new AdminApi();
        String list = card-poison; // String | Name of word list to use.
        String word = test; // String | Word to add/delete.

        try {
            putRoom_200_response result = apiInstance.deleteWord(list, word);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#deleteWord");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
AdminApi *apiInstance = [[AdminApi alloc] init];
String *list = card-poison; // Name of word list to use. (default to null)
String *word = test; // Word to add/delete. (default to null)

// Delete word from wordlist
[apiInstance deleteWordWith:list
    word:word
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.AdminApi()
var list = card-poison; // {String} Name of word list to use.
var word = test; // {String} Word to add/delete.

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

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

namespace Example
{
    public class deleteWordExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new AdminApi();
            var list = card-poison;  // String | Name of word list to use. (default to null)
            var word = test;  // String | Word to add/delete. (default to null)

            try {
                // Delete word from wordlist
                putRoom_200_response result = apiInstance.deleteWord(list, word);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminApi.deleteWord: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminApi();
$list = card-poison; // String | Name of word list to use.
$word = test; // String | Word to add/delete.

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminApi->new();
my $list = card-poison; # String | Name of word list to use.
my $word = test; # String | Word to add/delete.

eval {
    my $result = $api_instance->deleteWord(list => $list, word => $word);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminApi->deleteWord: $@\n";
}

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.AdminApi()
list = card-poison # String | Name of word list to use. (default to null)
word = test # String | Word to add/delete. (default to null)

try:
    # Delete word from wordlist
    api_response = api_instance.delete_word(list, word)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminApi->deleteWord: %s\n" % e)

extern crate AdminApi;

pub fn main() {
    let list = card-poison; // String
    let word = test; // String

    let mut context = AdminApi::Context::default();
    let result = client.deleteWord(list, word, &context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        AdminApi apiInstance = new AdminApi();
        String list = card-poison; // String | Name of word list to use.

        try {
            putRoom_200_response result = apiInstance.deleteWordList(list);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#deleteWordList");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String list = new String(); // String | Name of word list to use.

try {
    final result = await api_instance.deleteWordList(list);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteWordList: $e\n');
}

import org.openapitools.client.api.AdminApi;

public class AdminApiExample {
    public static void main(String[] args) {
        AdminApi apiInstance = new AdminApi();
        String list = card-poison; // String | Name of word list to use.

        try {
            putRoom_200_response result = apiInstance.deleteWordList(list);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#deleteWordList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
AdminApi *apiInstance = [[AdminApi alloc] init];
String *list = card-poison; // Name of word list to use. (default to null)

// Delete wordlist
[apiInstance deleteWordListWith:list
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.AdminApi()
var list = card-poison; // {String} Name of word list to use.

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

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

namespace Example
{
    public class deleteWordListExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new AdminApi();
            var list = card-poison;  // String | Name of word list to use. (default to null)

            try {
                // Delete wordlist
                putRoom_200_response result = apiInstance.deleteWordList(list);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminApi.deleteWordList: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminApi();
$list = card-poison; // String | Name of word list to use.

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminApi->new();
my $list = card-poison; # String | Name of word list to use.

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

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.AdminApi()
list = card-poison # String | Name of word list to use. (default to null)

try:
    # Delete wordlist
    api_response = api_instance.delete_word_list(list)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminApi->deleteWordList: %s\n" % e)

extern crate AdminApi;

pub fn main() {
    let list = card-poison; // String

    let mut context = AdminApi::Context::default();
    let result = client.deleteWordList(list, &context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        AdminApi apiInstance = new AdminApi();
        String list = card-poison; // String | Name of word list to use.
        WordsBody wordsBody = ; // WordsBody | 

        try {
            putRoom_200_response result = apiInstance.deleteWords(list, wordsBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#deleteWords");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String list = new String(); // String | Name of word list to use.
final WordsBody wordsBody = new WordsBody(); // WordsBody | 

try {
    final result = await api_instance.deleteWords(list, wordsBody);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteWords: $e\n');
}

import org.openapitools.client.api.AdminApi;

public class AdminApiExample {
    public static void main(String[] args) {
        AdminApi apiInstance = new AdminApi();
        String list = card-poison; // String | Name of word list to use.
        WordsBody wordsBody = ; // WordsBody | 

        try {
            putRoom_200_response result = apiInstance.deleteWords(list, wordsBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#deleteWords");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
AdminApi *apiInstance = [[AdminApi alloc] init];
String *list = card-poison; // Name of word list to use. (default to null)
WordsBody *wordsBody = ; //  (optional)

// Delete words from wordlist
[apiInstance deleteWordsWith:list
    wordsBody:wordsBody
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.AdminApi()
var list = card-poison; // {String} Name of word list to use.
var opts = {
  'wordsBody':  // {WordsBody} 
};

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

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

namespace Example
{
    public class deleteWordsExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new AdminApi();
            var list = card-poison;  // String | Name of word list to use. (default to null)
            var wordsBody = new WordsBody(); // WordsBody |  (optional) 

            try {
                // Delete words from wordlist
                putRoom_200_response result = apiInstance.deleteWords(list, wordsBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminApi.deleteWords: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminApi();
$list = card-poison; // String | Name of word list to use.
$wordsBody = ; // WordsBody | 

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminApi->new();
my $list = card-poison; # String | Name of word list to use.
my $wordsBody = WWW::OPenAPIClient::Object::WordsBody->new(); # WordsBody | 

eval {
    my $result = $api_instance->deleteWords(list => $list, wordsBody => $wordsBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminApi->deleteWords: $@\n";
}

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.AdminApi()
list = card-poison # String | Name of word list to use. (default to null)
wordsBody =  # WordsBody |  (optional)

try:
    # Delete words from wordlist
    api_response = api_instance.delete_words(list, wordsBody=wordsBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminApi->deleteWords: %s\n" % e)

extern crate AdminApi;

pub fn main() {
    let list = card-poison; // String
    let wordsBody = ; // WordsBody

    let mut context = AdminApi::Context::default();
    let result = client.deleteWords(list, wordsBody, &context).wait();

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

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        AdminApi apiInstance = new AdminApi();
        String room = galactic; // String | Name of room to use.
        String name = Vlad; // String | Name of player within a room.

        try {
            Player result = apiInstance.getPlayer(room, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#getPlayer");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String room = new String(); // String | Name of room to use.
final String name = new String(); // String | Name of player within a room.

try {
    final result = await api_instance.getPlayer(room, name);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getPlayer: $e\n');
}

import org.openapitools.client.api.AdminApi;

public class AdminApiExample {
    public static void main(String[] args) {
        AdminApi apiInstance = new AdminApi();
        String room = galactic; // String | Name of room to use.
        String name = Vlad; // String | Name of player within a room.

        try {
            Player result = apiInstance.getPlayer(room, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#getPlayer");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
AdminApi *apiInstance = [[AdminApi alloc] init];
String *room = galactic; // Name of room to use. (default to null)
String *name = Vlad; // Name of player within a room. (default to null)

// Get player
[apiInstance getPlayerWith:room
    name:name
              completionHandler: ^(Player output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

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

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.AdminApi()
var room = galactic; // {String} Name of room to use.
var name = Vlad; // {String} Name of player within a room.

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

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

namespace Example
{
    public class getPlayerExample
    {
        public void main()
        {
            // Configure API key authorization: UserAuth
            Configuration.Default.ApiKey.Add("X-Assassin-User", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-Assassin-User", "Bearer");
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new AdminApi();
            var room = galactic;  // String | Name of room to use. (default to null)
            var name = Vlad;  // String | Name of player within a room. (default to null)

            try {
                // Get player
                Player result = apiInstance.getPlayer(room, name);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminApi.getPlayer: " + e.Message );
            }
        }
    }
}

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

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminApi();
$room = galactic; // String | Name of room to use.
$name = Vlad; // String | Name of player within a room.

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

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminApi->new();
my $room = galactic; # String | Name of room to use.
my $name = Vlad; # String | Name of player within a room.

eval {
    my $result = $api_instance->getPlayer(room => $room, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminApi->getPlayer: $@\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: UserAuth
openapi_client.configuration.api_key['X-Assassin-User'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-Assassin-User'] = 'Bearer'

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.AdminApi()
room = galactic # String | Name of room to use. (default to null)
name = Vlad # String | Name of player within a room. (default to null)

try:
    # Get player
    api_response = api_instance.get_player(room, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminApi->getPlayer: %s\n" % e)

extern crate AdminApi;

pub fn main() {
    let room = galactic; // String
    let name = Vlad; // String

    let mut context = AdminApi::Context::default();
    let result = client.getPlayer(room, name, &context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        AdminApi apiInstance = new AdminApi();
        String list = card-poison; // String | Name of word list to use.

        try {
            putRoom_200_response result = apiInstance.importWordList(list);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#importWordList");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String list = new String(); // String | Name of word list to use.

try {
    final result = await api_instance.importWordList(list);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->importWordList: $e\n');
}

import org.openapitools.client.api.AdminApi;

public class AdminApiExample {
    public static void main(String[] args) {
        AdminApi apiInstance = new AdminApi();
        String list = card-poison; // String | Name of word list to use.

        try {
            putRoom_200_response result = apiInstance.importWordList(list);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#importWordList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
AdminApi *apiInstance = [[AdminApi alloc] init];
String *list = card-poison; // Name of word list to use. (default to null)

// Import or update wordlist.
[apiInstance importWordListWith:list
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.AdminApi()
var list = card-poison; // {String} Name of word list to use.

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

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

namespace Example
{
    public class importWordListExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new AdminApi();
            var list = card-poison;  // String | Name of word list to use. (default to null)

            try {
                // Import or update wordlist.
                putRoom_200_response result = apiInstance.importWordList(list);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminApi.importWordList: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminApi();
$list = card-poison; // String | Name of word list to use.

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminApi->new();
my $list = card-poison; # String | Name of word list to use.

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

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.AdminApi()
list = card-poison # String | Name of word list to use. (default to null)

try:
    # Import or update wordlist.
    api_response = api_instance.import_word_list(list)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminApi->importWordList: %s\n" % e)

extern crate AdminApi;

pub fn main() {
    let list = card-poison; // String

    let mut context = AdminApi::Context::default();
    let result = client.importWordList(list, &context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

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

        try {
            migrateDatabase_200_response result = apiInstance.migrateDatabase();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#migrateDatabase");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.migrateDatabase();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->migrateDatabase: $e\n');
}

import org.openapitools.client.api.AdminApi;

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

        try {
            migrateDatabase_200_response result = apiInstance.migrateDatabase();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#migrateDatabase");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

// Migrate database
[apiInstance migrateDatabaseWithCompletionHandler: 
              ^(migrateDatabase_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

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

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

namespace Example
{
    public class migrateDatabaseExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Migrate database
                migrateDatabase_200_response result = apiInstance.migrateDatabase();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminApi.migrateDatabase: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Migrate database
    api_response = api_instance.migrate_database()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminApi->migrateDatabase: %s\n" % e)

extern crate AdminApi;

pub fn main() {

    let mut context = AdminApi::Context::default();
    let result = client.migrateDatabase(&context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        AdminApi apiInstance = new AdminApi();
        String room = galactic; // String | Name of room to use.
        UpdateRoomBody updateRoomBody = ; // UpdateRoomBody | 

        try {
            putRoom_200_response result = apiInstance.patchRoom(room, updateRoomBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#patchRoom");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String room = new String(); // String | Name of room to use.
final UpdateRoomBody updateRoomBody = new UpdateRoomBody(); // UpdateRoomBody | 

try {
    final result = await api_instance.patchRoom(room, updateRoomBody);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->patchRoom: $e\n');
}

import org.openapitools.client.api.AdminApi;

public class AdminApiExample {
    public static void main(String[] args) {
        AdminApi apiInstance = new AdminApi();
        String room = galactic; // String | Name of room to use.
        UpdateRoomBody updateRoomBody = ; // UpdateRoomBody | 

        try {
            putRoom_200_response result = apiInstance.patchRoom(room, updateRoomBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#patchRoom");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
AdminApi *apiInstance = [[AdminApi alloc] init];
String *room = galactic; // Name of room to use. (default to null)
UpdateRoomBody *updateRoomBody = ; //  (optional)

// Update room
[apiInstance patchRoomWith:room
    updateRoomBody:updateRoomBody
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.AdminApi()
var room = galactic; // {String} Name of room to use.
var opts = {
  'updateRoomBody':  // {UpdateRoomBody} 
};

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

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

namespace Example
{
    public class patchRoomExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new AdminApi();
            var room = galactic;  // String | Name of room to use. (default to null)
            var updateRoomBody = new UpdateRoomBody(); // UpdateRoomBody |  (optional) 

            try {
                // Update room
                putRoom_200_response result = apiInstance.patchRoom(room, updateRoomBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminApi.patchRoom: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminApi();
$room = galactic; // String | Name of room to use.
$updateRoomBody = ; // UpdateRoomBody | 

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminApi->new();
my $room = galactic; # String | Name of room to use.
my $updateRoomBody = WWW::OPenAPIClient::Object::UpdateRoomBody->new(); # UpdateRoomBody | 

eval {
    my $result = $api_instance->patchRoom(room => $room, updateRoomBody => $updateRoomBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminApi->patchRoom: $@\n";
}

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.AdminApi()
room = galactic # String | Name of room to use. (default to null)
updateRoomBody =  # UpdateRoomBody |  (optional)

try:
    # Update room
    api_response = api_instance.patch_room(room, updateRoomBody=updateRoomBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminApi->patchRoom: %s\n" % e)

extern crate AdminApi;

pub fn main() {
    let room = galactic; // String
    let updateRoomBody = ; // UpdateRoomBody

    let mut context = AdminApi::Context::default();
    let result = client.patchRoom(room, updateRoomBody, &context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        AdminApi apiInstance = new AdminApi();
        String list = card-poison; // String | Name of word list to use.
        UpdateWordlistBody updateWordlistBody = ; // UpdateWordlistBody | 

        try {
            putRoom_200_response result = apiInstance.patchWordList(list, updateWordlistBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#patchWordList");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String list = new String(); // String | Name of word list to use.
final UpdateWordlistBody updateWordlistBody = new UpdateWordlistBody(); // UpdateWordlistBody | 

try {
    final result = await api_instance.patchWordList(list, updateWordlistBody);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->patchWordList: $e\n');
}

import org.openapitools.client.api.AdminApi;

public class AdminApiExample {
    public static void main(String[] args) {
        AdminApi apiInstance = new AdminApi();
        String list = card-poison; // String | Name of word list to use.
        UpdateWordlistBody updateWordlistBody = ; // UpdateWordlistBody | 

        try {
            putRoom_200_response result = apiInstance.patchWordList(list, updateWordlistBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#patchWordList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
AdminApi *apiInstance = [[AdminApi alloc] init];
String *list = card-poison; // Name of word list to use. (default to null)
UpdateWordlistBody *updateWordlistBody = ; //  (optional)

// Update wordlist
[apiInstance patchWordListWith:list
    updateWordlistBody:updateWordlistBody
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.AdminApi()
var list = card-poison; // {String} Name of word list to use.
var opts = {
  'updateWordlistBody':  // {UpdateWordlistBody} 
};

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

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

namespace Example
{
    public class patchWordListExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new AdminApi();
            var list = card-poison;  // String | Name of word list to use. (default to null)
            var updateWordlistBody = new UpdateWordlistBody(); // UpdateWordlistBody |  (optional) 

            try {
                // Update wordlist
                putRoom_200_response result = apiInstance.patchWordList(list, updateWordlistBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminApi.patchWordList: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminApi();
$list = card-poison; // String | Name of word list to use.
$updateWordlistBody = ; // UpdateWordlistBody | 

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminApi->new();
my $list = card-poison; # String | Name of word list to use.
my $updateWordlistBody = WWW::OPenAPIClient::Object::UpdateWordlistBody->new(); # UpdateWordlistBody | 

eval {
    my $result = $api_instance->patchWordList(list => $list, updateWordlistBody => $updateWordlistBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminApi->patchWordList: $@\n";
}

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.AdminApi()
list = card-poison # String | Name of word list to use. (default to null)
updateWordlistBody =  # UpdateWordlistBody |  (optional)

try:
    # Update wordlist
    api_response = api_instance.patch_word_list(list, updateWordlistBody=updateWordlistBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminApi->patchWordList: %s\n" % e)

extern crate AdminApi;

pub fn main() {
    let list = card-poison; // String
    let updateWordlistBody = ; // UpdateWordlistBody

    let mut context = AdminApi::Context::default();
    let result = client.patchWordList(list, updateWordlistBody, &context).wait();

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

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        AdminApi apiInstance = new AdminApi();
        String room = galactic; // String | Name of room to use.
        String name = Vlad; // String | Name of player within a room.

        try {
            putRoom_200_response result = apiInstance.putPlayer(room, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#putPlayer");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String room = new String(); // String | Name of room to use.
final String name = new String(); // String | Name of player within a room.

try {
    final result = await api_instance.putPlayer(room, name);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->putPlayer: $e\n');
}

import org.openapitools.client.api.AdminApi;

public class AdminApiExample {
    public static void main(String[] args) {
        AdminApi apiInstance = new AdminApi();
        String room = galactic; // String | Name of room to use.
        String name = Vlad; // String | Name of player within a room.

        try {
            putRoom_200_response result = apiInstance.putPlayer(room, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#putPlayer");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
AdminApi *apiInstance = [[AdminApi alloc] init];
String *room = galactic; // Name of room to use. (default to null)
String *name = Vlad; // Name of player within a room. (default to null)

// Add player
[apiInstance putPlayerWith:room
    name:name
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

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

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.AdminApi()
var room = galactic; // {String} Name of room to use.
var name = Vlad; // {String} Name of player within a room.

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

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

namespace Example
{
    public class putPlayerExample
    {
        public void main()
        {
            // Configure API key authorization: UserAuth
            Configuration.Default.ApiKey.Add("X-Assassin-User", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-Assassin-User", "Bearer");
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new AdminApi();
            var room = galactic;  // String | Name of room to use. (default to null)
            var name = Vlad;  // String | Name of player within a room. (default to null)

            try {
                // Add player
                putRoom_200_response result = apiInstance.putPlayer(room, name);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminApi.putPlayer: " + e.Message );
            }
        }
    }
}

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

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminApi();
$room = galactic; // String | Name of room to use.
$name = Vlad; // String | Name of player within a room.

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

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminApi->new();
my $room = galactic; # String | Name of room to use.
my $name = Vlad; # String | Name of player within a room.

eval {
    my $result = $api_instance->putPlayer(room => $room, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminApi->putPlayer: $@\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: UserAuth
openapi_client.configuration.api_key['X-Assassin-User'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-Assassin-User'] = 'Bearer'

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.AdminApi()
room = galactic # String | Name of room to use. (default to null)
name = Vlad # String | Name of player within a room. (default to null)

try:
    # Add player
    api_response = api_instance.put_player(room, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminApi->putPlayer: %s\n" % e)

extern crate AdminApi;

pub fn main() {
    let room = galactic; // String
    let name = Vlad; // String

    let mut context = AdminApi::Context::default();
    let result = client.putPlayer(room, name, &context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        AdminApi apiInstance = new AdminApi();
        String room = galactic; // String | Name of room to use.
        AddRoomBody addRoomBody = ; // AddRoomBody | 

        try {
            putRoom_200_response result = apiInstance.putRoom(room, addRoomBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#putRoom");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String room = new String(); // String | Name of room to use.
final AddRoomBody addRoomBody = new AddRoomBody(); // AddRoomBody | 

try {
    final result = await api_instance.putRoom(room, addRoomBody);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->putRoom: $e\n');
}

import org.openapitools.client.api.AdminApi;

public class AdminApiExample {
    public static void main(String[] args) {
        AdminApi apiInstance = new AdminApi();
        String room = galactic; // String | Name of room to use.
        AddRoomBody addRoomBody = ; // AddRoomBody | 

        try {
            putRoom_200_response result = apiInstance.putRoom(room, addRoomBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#putRoom");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
AdminApi *apiInstance = [[AdminApi alloc] init];
String *room = galactic; // Name of room to use. (default to null)
AddRoomBody *addRoomBody = ; //  (optional)

// Add room
[apiInstance putRoomWith:room
    addRoomBody:addRoomBody
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.AdminApi()
var room = galactic; // {String} Name of room to use.
var opts = {
  'addRoomBody':  // {AddRoomBody} 
};

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

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

namespace Example
{
    public class putRoomExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new AdminApi();
            var room = galactic;  // String | Name of room to use. (default to null)
            var addRoomBody = new AddRoomBody(); // AddRoomBody |  (optional) 

            try {
                // Add room
                putRoom_200_response result = apiInstance.putRoom(room, addRoomBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminApi.putRoom: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminApi();
$room = galactic; // String | Name of room to use.
$addRoomBody = ; // AddRoomBody | 

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminApi->new();
my $room = galactic; # String | Name of room to use.
my $addRoomBody = WWW::OPenAPIClient::Object::AddRoomBody->new(); # AddRoomBody | 

eval {
    my $result = $api_instance->putRoom(room => $room, addRoomBody => $addRoomBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminApi->putRoom: $@\n";
}

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.AdminApi()
room = galactic # String | Name of room to use. (default to null)
addRoomBody =  # AddRoomBody |  (optional)

try:
    # Add room
    api_response = api_instance.put_room(room, addRoomBody=addRoomBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminApi->putRoom: %s\n" % e)

extern crate AdminApi;

pub fn main() {
    let room = galactic; // String
    let addRoomBody = ; // AddRoomBody

    let mut context = AdminApi::Context::default();
    let result = client.putRoom(room, addRoomBody, &context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        AdminApi apiInstance = new AdminApi();
        String list = card-poison; // String | Name of word list to use.
        String word = test; // String | Word to add/delete.

        try {
            putRoom_200_response result = apiInstance.putWord(list, word);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#putWord");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String list = new String(); // String | Name of word list to use.
final String word = new String(); // String | Word to add/delete.

try {
    final result = await api_instance.putWord(list, word);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->putWord: $e\n');
}

import org.openapitools.client.api.AdminApi;

public class AdminApiExample {
    public static void main(String[] args) {
        AdminApi apiInstance = new AdminApi();
        String list = card-poison; // String | Name of word list to use.
        String word = test; // String | Word to add/delete.

        try {
            putRoom_200_response result = apiInstance.putWord(list, word);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#putWord");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
AdminApi *apiInstance = [[AdminApi alloc] init];
String *list = card-poison; // Name of word list to use. (default to null)
String *word = test; // Word to add/delete. (default to null)

// Add word to wordlist
[apiInstance putWordWith:list
    word:word
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.AdminApi()
var list = card-poison; // {String} Name of word list to use.
var word = test; // {String} Word to add/delete.

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

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

namespace Example
{
    public class putWordExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new AdminApi();
            var list = card-poison;  // String | Name of word list to use. (default to null)
            var word = test;  // String | Word to add/delete. (default to null)

            try {
                // Add word to wordlist
                putRoom_200_response result = apiInstance.putWord(list, word);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminApi.putWord: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminApi();
$list = card-poison; // String | Name of word list to use.
$word = test; // String | Word to add/delete.

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminApi->new();
my $list = card-poison; # String | Name of word list to use.
my $word = test; # String | Word to add/delete.

eval {
    my $result = $api_instance->putWord(list => $list, word => $word);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminApi->putWord: $@\n";
}

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.AdminApi()
list = card-poison # String | Name of word list to use. (default to null)
word = test # String | Word to add/delete. (default to null)

try:
    # Add word to wordlist
    api_response = api_instance.put_word(list, word)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminApi->putWord: %s\n" % e)

extern crate AdminApi;

pub fn main() {
    let list = card-poison; // String
    let word = test; // String

    let mut context = AdminApi::Context::default();
    let result = client.putWord(list, word, &context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        AdminApi apiInstance = new AdminApi();
        String list = card-poison; // String | Name of word list to use.
        WordlistBody wordlistBody = ; // WordlistBody | 

        try {
            putRoom_200_response result = apiInstance.putWordList(list, wordlistBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#putWordList");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String list = new String(); // String | Name of word list to use.
final WordlistBody wordlistBody = new WordlistBody(); // WordlistBody | 

try {
    final result = await api_instance.putWordList(list, wordlistBody);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->putWordList: $e\n');
}

import org.openapitools.client.api.AdminApi;

public class AdminApiExample {
    public static void main(String[] args) {
        AdminApi apiInstance = new AdminApi();
        String list = card-poison; // String | Name of word list to use.
        WordlistBody wordlistBody = ; // WordlistBody | 

        try {
            putRoom_200_response result = apiInstance.putWordList(list, wordlistBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#putWordList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
AdminApi *apiInstance = [[AdminApi alloc] init];
String *list = card-poison; // Name of word list to use. (default to null)
WordlistBody *wordlistBody = ; //  (optional)

// Add wordlist
[apiInstance putWordListWith:list
    wordlistBody:wordlistBody
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.AdminApi()
var list = card-poison; // {String} Name of word list to use.
var opts = {
  'wordlistBody':  // {WordlistBody} 
};

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

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

namespace Example
{
    public class putWordListExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new AdminApi();
            var list = card-poison;  // String | Name of word list to use. (default to null)
            var wordlistBody = new WordlistBody(); // WordlistBody |  (optional) 

            try {
                // Add wordlist
                putRoom_200_response result = apiInstance.putWordList(list, wordlistBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminApi.putWordList: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminApi();
$list = card-poison; // String | Name of word list to use.
$wordlistBody = ; // WordlistBody | 

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminApi->new();
my $list = card-poison; # String | Name of word list to use.
my $wordlistBody = WWW::OPenAPIClient::Object::WordlistBody->new(); # WordlistBody | 

eval {
    my $result = $api_instance->putWordList(list => $list, wordlistBody => $wordlistBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminApi->putWordList: $@\n";
}

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.AdminApi()
list = card-poison # String | Name of word list to use. (default to null)
wordlistBody =  # WordlistBody |  (optional)

try:
    # Add wordlist
    api_response = api_instance.put_word_list(list, wordlistBody=wordlistBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminApi->putWordList: %s\n" % e)

extern crate AdminApi;

pub fn main() {
    let list = card-poison; // String
    let wordlistBody = ; // WordlistBody

    let mut context = AdminApi::Context::default();
    let result = client.putWordList(list, wordlistBody, &context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        AdminApi apiInstance = new AdminApi();
        String list = card-poison; // String | Name of word list to use.
        WordsBody wordsBody = ; // WordsBody | 

        try {
            putRoom_200_response result = apiInstance.putWords(list, wordsBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#putWords");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String list = new String(); // String | Name of word list to use.
final WordsBody wordsBody = new WordsBody(); // WordsBody | 

try {
    final result = await api_instance.putWords(list, wordsBody);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->putWords: $e\n');
}

import org.openapitools.client.api.AdminApi;

public class AdminApiExample {
    public static void main(String[] args) {
        AdminApi apiInstance = new AdminApi();
        String list = card-poison; // String | Name of word list to use.
        WordsBody wordsBody = ; // WordsBody | 

        try {
            putRoom_200_response result = apiInstance.putWords(list, wordsBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#putWords");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
AdminApi *apiInstance = [[AdminApi alloc] init];
String *list = card-poison; // Name of word list to use. (default to null)
WordsBody *wordsBody = ; //  (optional)

// Add words to wordlist
[apiInstance putWordsWith:list
    wordsBody:wordsBody
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.AdminApi()
var list = card-poison; // {String} Name of word list to use.
var opts = {
  'wordsBody':  // {WordsBody} 
};

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

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

namespace Example
{
    public class putWordsExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new AdminApi();
            var list = card-poison;  // String | Name of word list to use. (default to null)
            var wordsBody = new WordsBody(); // WordsBody |  (optional) 

            try {
                // Add words to wordlist
                putRoom_200_response result = apiInstance.putWords(list, wordsBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminApi.putWords: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminApi();
$list = card-poison; // String | Name of word list to use.
$wordsBody = ; // WordsBody | 

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminApi->new();
my $list = card-poison; # String | Name of word list to use.
my $wordsBody = WWW::OPenAPIClient::Object::WordsBody->new(); # WordsBody | 

eval {
    my $result = $api_instance->putWords(list => $list, wordsBody => $wordsBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminApi->putWords: $@\n";
}

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.AdminApi()
list = card-poison # String | Name of word list to use. (default to null)
wordsBody =  # WordsBody |  (optional)

try:
    # Add words to wordlist
    api_response = api_instance.put_words(list, wordsBody=wordsBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminApi->putWords: %s\n" % e)

extern crate AdminApi;

pub fn main() {
    let list = card-poison; // String
    let wordsBody = ; // WordsBody

    let mut context = AdminApi::Context::default();
    let result = client.putWords(list, wordsBody, &context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

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

        try {
            putRoom_200_response result = apiInstance.resetDatabase();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#resetDatabase");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.resetDatabase();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->resetDatabase: $e\n');
}

import org.openapitools.client.api.AdminApi;

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

        try {
            putRoom_200_response result = apiInstance.resetDatabase();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#resetDatabase");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

// Reset database
[apiInstance resetDatabaseWithCompletionHandler: 
              ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

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

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

namespace Example
{
    public class resetDatabaseExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Reset database
                putRoom_200_response result = apiInstance.resetDatabase();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminApi.resetDatabase: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Reset database
    api_response = api_instance.reset_database()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminApi->resetDatabase: %s\n" % e)

extern crate AdminApi;

pub fn main() {

    let mut context = AdminApi::Context::default();
    let result = client.resetDatabase(&context).wait();

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

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        AdminApi apiInstance = new AdminApi();
        String room = galactic; // String | Name of room to use.

        try {
            putRoom_200_response result = apiInstance.resetRoom(room);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#resetRoom");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String room = new String(); // String | Name of room to use.

try {
    final result = await api_instance.resetRoom(room);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->resetRoom: $e\n');
}

import org.openapitools.client.api.AdminApi;

public class AdminApiExample {
    public static void main(String[] args) {
        AdminApi apiInstance = new AdminApi();
        String room = galactic; // String | Name of room to use.

        try {
            putRoom_200_response result = apiInstance.resetRoom(room);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#resetRoom");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
AdminApi *apiInstance = [[AdminApi alloc] init];
String *room = galactic; // Name of room to use. (default to null)

// Reset room
[apiInstance resetRoomWith:room
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

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

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.AdminApi()
var room = galactic; // {String} Name of room to use.

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

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

namespace Example
{
    public class resetRoomExample
    {
        public void main()
        {
            // Configure API key authorization: UserAuth
            Configuration.Default.ApiKey.Add("X-Assassin-User", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-Assassin-User", "Bearer");
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new AdminApi();
            var room = galactic;  // String | Name of room to use. (default to null)

            try {
                // Reset room
                putRoom_200_response result = apiInstance.resetRoom(room);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminApi.resetRoom: " + e.Message );
            }
        }
    }
}

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

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminApi();
$room = galactic; // String | Name of room to use.

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

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminApi->new();
my $room = galactic; # String | Name of room to use.

eval {
    my $result = $api_instance->resetRoom(room => $room);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminApi->resetRoom: $@\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: UserAuth
openapi_client.configuration.api_key['X-Assassin-User'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-Assassin-User'] = 'Bearer'

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.AdminApi()
room = galactic # String | Name of room to use. (default to null)

try:
    # Reset room
    api_response = api_instance.reset_room(room)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminApi->resetRoom: %s\n" % e)

extern crate AdminApi;

pub fn main() {
    let room = galactic; // String

    let mut context = AdminApi::Context::default();
    let result = client.resetRoom(room, &context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

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

        try {
            migrateDatabase_200_response result = apiInstance.rollbackDatabase();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#rollbackDatabase");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.rollbackDatabase();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->rollbackDatabase: $e\n');
}

import org.openapitools.client.api.AdminApi;

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

        try {
            migrateDatabase_200_response result = apiInstance.rollbackDatabase();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#rollbackDatabase");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

// Rollback migration
[apiInstance rollbackDatabaseWithCompletionHandler: 
              ^(migrateDatabase_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

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

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

namespace Example
{
    public class rollbackDatabaseExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Rollback migration
                migrateDatabase_200_response result = apiInstance.rollbackDatabase();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminApi.rollbackDatabase: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Rollback migration
    api_response = api_instance.rollback_database()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminApi->rollbackDatabase: %s\n" % e)

extern crate AdminApi;

pub fn main() {

    let mut context = AdminApi::Context::default();
    let result = client.rollbackDatabase(&context).wait();

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

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        AdminApi apiInstance = new AdminApi();
        String room = galactic; // String | Name of room to use.

        try {
            putRoom_200_response result = apiInstance.setGM(room);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#setGM");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String room = new String(); // String | Name of room to use.

try {
    final result = await api_instance.setGM(room);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->setGM: $e\n');
}

import org.openapitools.client.api.AdminApi;

public class AdminApiExample {
    public static void main(String[] args) {
        AdminApi apiInstance = new AdminApi();
        String room = galactic; // String | Name of room to use.

        try {
            putRoom_200_response result = apiInstance.setGM(room);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#setGM");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
AdminApi *apiInstance = [[AdminApi alloc] init];
String *room = galactic; // Name of room to use. (default to null)

// Set GM
[apiInstance setGMWith:room
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

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

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.AdminApi()
var room = galactic; // {String} Name of room to use.

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

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

namespace Example
{
    public class setGMExample
    {
        public void main()
        {
            // Configure API key authorization: UserAuth
            Configuration.Default.ApiKey.Add("X-Assassin-User", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-Assassin-User", "Bearer");
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new AdminApi();
            var room = galactic;  // String | Name of room to use. (default to null)

            try {
                // Set GM
                putRoom_200_response result = apiInstance.setGM(room);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminApi.setGM: " + e.Message );
            }
        }
    }
}

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

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminApi();
$room = galactic; // String | Name of room to use.

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

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminApi->new();
my $room = galactic; # String | Name of room to use.

eval {
    my $result = $api_instance->setGM(room => $room);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminApi->setGM: $@\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: UserAuth
openapi_client.configuration.api_key['X-Assassin-User'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-Assassin-User'] = 'Bearer'

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.AdminApi()
room = galactic # String | Name of room to use. (default to null)

try:
    # Set GM
    api_response = api_instance.set_gm(room)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminApi->setGM: %s\n" % e)

extern crate AdminApi;

pub fn main() {
    let room = galactic; // String

    let mut context = AdminApi::Context::default();
    let result = client.setGM(room, &context).wait();

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

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        AdminApi apiInstance = new AdminApi();
        String room = galactic; // String | Name of room to use.

        try {
            putRoom_200_response result = apiInstance.startRoom(room);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#startRoom");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String room = new String(); // String | Name of room to use.

try {
    final result = await api_instance.startRoom(room);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->startRoom: $e\n');
}

import org.openapitools.client.api.AdminApi;

public class AdminApiExample {
    public static void main(String[] args) {
        AdminApi apiInstance = new AdminApi();
        String room = galactic; // String | Name of room to use.

        try {
            putRoom_200_response result = apiInstance.startRoom(room);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#startRoom");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
AdminApi *apiInstance = [[AdminApi alloc] init];
String *room = galactic; // Name of room to use. (default to null)

// Start game
[apiInstance startRoomWith:room
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

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

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.AdminApi()
var room = galactic; // {String} Name of room to use.

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

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

namespace Example
{
    public class startRoomExample
    {
        public void main()
        {
            // Configure API key authorization: UserAuth
            Configuration.Default.ApiKey.Add("X-Assassin-User", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-Assassin-User", "Bearer");
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new AdminApi();
            var room = galactic;  // String | Name of room to use. (default to null)

            try {
                // Start game
                putRoom_200_response result = apiInstance.startRoom(room);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminApi.startRoom: " + e.Message );
            }
        }
    }
}

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

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminApi();
$room = galactic; // String | Name of room to use.

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

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminApi->new();
my $room = galactic; # String | Name of room to use.

eval {
    my $result = $api_instance->startRoom(room => $room);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminApi->startRoom: $@\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: UserAuth
openapi_client.configuration.api_key['X-Assassin-User'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-Assassin-User'] = 'Bearer'

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.AdminApi()
room = galactic # String | Name of room to use. (default to null)

try:
    # Start game
    api_response = api_instance.start_room(room)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminApi->startRoom: %s\n" % e)

extern crate AdminApi;

pub fn main() {
    let room = galactic; // String

    let mut context = AdminApi::Context::default();
    let result = client.startRoom(room, &context).wait();

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

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

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

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

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

        try {
            getDatabase_200_response result = apiInstance.getDatabase();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseApi#getDatabase");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.getDatabase();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getDatabase: $e\n');
}

import org.openapitools.client.api.DatabaseApi;

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

        try {
            getDatabase_200_response result = apiInstance.getDatabase();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseApi#getDatabase");
            e.printStackTrace();
        }
    }
}

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

// Get database info
[apiInstance getDatabaseWithCompletionHandler: 
              ^(getDatabase_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');

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

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

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

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

            try {
                // Get database info
                getDatabase_200_response result = apiInstance.getDatabase();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DatabaseApi.getDatabase: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->getDatabase();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatabaseApi->getDatabase: $@\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.DatabaseApi()

try:
    # Get database info
    api_response = api_instance.get_database()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatabaseApi->getDatabase: %s\n" % e)

extern crate DatabaseApi;

pub fn main() {

    let mut context = DatabaseApi::Context::default();
    let result = client.getDatabase(&context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

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

        try {
            migrateDatabase_200_response result = apiInstance.migrateDatabase();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseApi#migrateDatabase");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.migrateDatabase();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->migrateDatabase: $e\n');
}

import org.openapitools.client.api.DatabaseApi;

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

        try {
            migrateDatabase_200_response result = apiInstance.migrateDatabase();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseApi#migrateDatabase");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

// Migrate database
[apiInstance migrateDatabaseWithCompletionHandler: 
              ^(migrateDatabase_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

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

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

namespace Example
{
    public class migrateDatabaseExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Migrate database
                migrateDatabase_200_response result = apiInstance.migrateDatabase();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DatabaseApi.migrateDatabase: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Migrate database
    api_response = api_instance.migrate_database()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatabaseApi->migrateDatabase: %s\n" % e)

extern crate DatabaseApi;

pub fn main() {

    let mut context = DatabaseApi::Context::default();
    let result = client.migrateDatabase(&context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

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

        try {
            putRoom_200_response result = apiInstance.resetDatabase();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseApi#resetDatabase");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.resetDatabase();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->resetDatabase: $e\n');
}

import org.openapitools.client.api.DatabaseApi;

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

        try {
            putRoom_200_response result = apiInstance.resetDatabase();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseApi#resetDatabase");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

// Reset database
[apiInstance resetDatabaseWithCompletionHandler: 
              ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

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

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

namespace Example
{
    public class resetDatabaseExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Reset database
                putRoom_200_response result = apiInstance.resetDatabase();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DatabaseApi.resetDatabase: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Reset database
    api_response = api_instance.reset_database()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatabaseApi->resetDatabase: %s\n" % e)

extern crate DatabaseApi;

pub fn main() {

    let mut context = DatabaseApi::Context::default();
    let result = client.resetDatabase(&context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

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

        try {
            migrateDatabase_200_response result = apiInstance.rollbackDatabase();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseApi#rollbackDatabase");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.rollbackDatabase();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->rollbackDatabase: $e\n');
}

import org.openapitools.client.api.DatabaseApi;

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

        try {
            migrateDatabase_200_response result = apiInstance.rollbackDatabase();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseApi#rollbackDatabase");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

// Rollback migration
[apiInstance rollbackDatabaseWithCompletionHandler: 
              ^(migrateDatabase_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

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

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

namespace Example
{
    public class rollbackDatabaseExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Rollback migration
                migrateDatabase_200_response result = apiInstance.rollbackDatabase();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DatabaseApi.rollbackDatabase: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Rollback migration
    api_response = api_instance.rollback_database()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatabaseApi->rollbackDatabase: %s\n" % e)

extern crate DatabaseApi;

pub fn main() {

    let mut context = DatabaseApi::Context::default();
    let result = client.rollbackDatabase(&context).wait();

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

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        GMApi apiInstance = new GMApi();
        String room = galactic; // String | Name of room to use.

        try {
            putRoom_200_response result = apiInstance.assignGM(room);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GMApi#assignGM");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String room = new String(); // String | Name of room to use.

try {
    final result = await api_instance.assignGM(room);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->assignGM: $e\n');
}

import org.openapitools.client.api.GMApi;

public class GMApiExample {
    public static void main(String[] args) {
        GMApi apiInstance = new GMApi();
        String room = galactic; // String | Name of room to use.

        try {
            putRoom_200_response result = apiInstance.assignGM(room);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GMApi#assignGM");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
GMApi *apiInstance = [[GMApi alloc] init];
String *room = galactic; // Name of room to use. (default to null)

// Randomly assign GM
[apiInstance assignGMWith:room
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

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

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.GMApi()
var room = galactic; // {String} Name of room to use.

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

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

namespace Example
{
    public class assignGMExample
    {
        public void main()
        {
            // Configure API key authorization: UserAuth
            Configuration.Default.ApiKey.Add("X-Assassin-User", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-Assassin-User", "Bearer");
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new GMApi();
            var room = galactic;  // String | Name of room to use. (default to null)

            try {
                // Randomly assign GM
                putRoom_200_response result = apiInstance.assignGM(room);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GMApi.assignGM: " + e.Message );
            }
        }
    }
}

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

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GMApi();
$room = galactic; // String | Name of room to use.

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

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GMApi->new();
my $room = galactic; # String | Name of room to use.

eval {
    my $result = $api_instance->assignGM(room => $room);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GMApi->assignGM: $@\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: UserAuth
openapi_client.configuration.api_key['X-Assassin-User'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-Assassin-User'] = 'Bearer'

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.GMApi()
room = galactic # String | Name of room to use. (default to null)

try:
    # Randomly assign GM
    api_response = api_instance.assign_gm(room)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GMApi->assignGM: %s\n" % e)

extern crate GMApi;

pub fn main() {
    let room = galactic; // String

    let mut context = GMApi::Context::default();
    let result = client.assignGM(room, &context).wait();

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

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        GMApi apiInstance = new GMApi();
        String room = galactic; // String | Name of room to use.
        String name = Vlad; // String | Name of player within a room.

        try {
            putRoom_200_response result = apiInstance.deletePlayer(room, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GMApi#deletePlayer");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String room = new String(); // String | Name of room to use.
final String name = new String(); // String | Name of player within a room.

try {
    final result = await api_instance.deletePlayer(room, name);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deletePlayer: $e\n');
}

import org.openapitools.client.api.GMApi;

public class GMApiExample {
    public static void main(String[] args) {
        GMApi apiInstance = new GMApi();
        String room = galactic; // String | Name of room to use.
        String name = Vlad; // String | Name of player within a room.

        try {
            putRoom_200_response result = apiInstance.deletePlayer(room, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GMApi#deletePlayer");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
GMApi *apiInstance = [[GMApi alloc] init];
String *room = galactic; // Name of room to use. (default to null)
String *name = Vlad; // Name of player within a room. (default to null)

// Delete player
[apiInstance deletePlayerWith:room
    name:name
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

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

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.GMApi()
var room = galactic; // {String} Name of room to use.
var name = Vlad; // {String} Name of player within a room.

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

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

namespace Example
{
    public class deletePlayerExample
    {
        public void main()
        {
            // Configure API key authorization: UserAuth
            Configuration.Default.ApiKey.Add("X-Assassin-User", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-Assassin-User", "Bearer");
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new GMApi();
            var room = galactic;  // String | Name of room to use. (default to null)
            var name = Vlad;  // String | Name of player within a room. (default to null)

            try {
                // Delete player
                putRoom_200_response result = apiInstance.deletePlayer(room, name);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GMApi.deletePlayer: " + e.Message );
            }
        }
    }
}

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

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GMApi();
$room = galactic; // String | Name of room to use.
$name = Vlad; // String | Name of player within a room.

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

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GMApi->new();
my $room = galactic; # String | Name of room to use.
my $name = Vlad; # String | Name of player within a room.

eval {
    my $result = $api_instance->deletePlayer(room => $room, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GMApi->deletePlayer: $@\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: UserAuth
openapi_client.configuration.api_key['X-Assassin-User'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-Assassin-User'] = 'Bearer'

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.GMApi()
room = galactic # String | Name of room to use. (default to null)
name = Vlad # String | Name of player within a room. (default to null)

try:
    # Delete player
    api_response = api_instance.delete_player(room, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GMApi->deletePlayer: %s\n" % e)

extern crate GMApi;

pub fn main() {
    let room = galactic; // String
    let name = Vlad; // String

    let mut context = GMApi::Context::default();
    let result = client.deletePlayer(room, name, &context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        GMApi apiInstance = new GMApi();
        String room = galactic; // String | Name of room to use.
        UpdateRoomBody updateRoomBody = ; // UpdateRoomBody | 

        try {
            putRoom_200_response result = apiInstance.patchRoom(room, updateRoomBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GMApi#patchRoom");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String room = new String(); // String | Name of room to use.
final UpdateRoomBody updateRoomBody = new UpdateRoomBody(); // UpdateRoomBody | 

try {
    final result = await api_instance.patchRoom(room, updateRoomBody);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->patchRoom: $e\n');
}

import org.openapitools.client.api.GMApi;

public class GMApiExample {
    public static void main(String[] args) {
        GMApi apiInstance = new GMApi();
        String room = galactic; // String | Name of room to use.
        UpdateRoomBody updateRoomBody = ; // UpdateRoomBody | 

        try {
            putRoom_200_response result = apiInstance.patchRoom(room, updateRoomBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GMApi#patchRoom");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
GMApi *apiInstance = [[GMApi alloc] init];
String *room = galactic; // Name of room to use. (default to null)
UpdateRoomBody *updateRoomBody = ; //  (optional)

// Update room
[apiInstance patchRoomWith:room
    updateRoomBody:updateRoomBody
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.GMApi()
var room = galactic; // {String} Name of room to use.
var opts = {
  'updateRoomBody':  // {UpdateRoomBody} 
};

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

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

namespace Example
{
    public class patchRoomExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new GMApi();
            var room = galactic;  // String | Name of room to use. (default to null)
            var updateRoomBody = new UpdateRoomBody(); // UpdateRoomBody |  (optional) 

            try {
                // Update room
                putRoom_200_response result = apiInstance.patchRoom(room, updateRoomBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GMApi.patchRoom: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GMApi();
$room = galactic; // String | Name of room to use.
$updateRoomBody = ; // UpdateRoomBody | 

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GMApi->new();
my $room = galactic; # String | Name of room to use.
my $updateRoomBody = WWW::OPenAPIClient::Object::UpdateRoomBody->new(); # UpdateRoomBody | 

eval {
    my $result = $api_instance->patchRoom(room => $room, updateRoomBody => $updateRoomBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GMApi->patchRoom: $@\n";
}

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.GMApi()
room = galactic # String | Name of room to use. (default to null)
updateRoomBody =  # UpdateRoomBody |  (optional)

try:
    # Update room
    api_response = api_instance.patch_room(room, updateRoomBody=updateRoomBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GMApi->patchRoom: %s\n" % e)

extern crate GMApi;

pub fn main() {
    let room = galactic; // String
    let updateRoomBody = ; // UpdateRoomBody

    let mut context = GMApi::Context::default();
    let result = client.patchRoom(room, updateRoomBody, &context).wait();

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

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        GMApi apiInstance = new GMApi();
        String room = galactic; // String | Name of room to use.

        try {
            putRoom_200_response result = apiInstance.resetRoom(room);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GMApi#resetRoom");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String room = new String(); // String | Name of room to use.

try {
    final result = await api_instance.resetRoom(room);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->resetRoom: $e\n');
}

import org.openapitools.client.api.GMApi;

public class GMApiExample {
    public static void main(String[] args) {
        GMApi apiInstance = new GMApi();
        String room = galactic; // String | Name of room to use.

        try {
            putRoom_200_response result = apiInstance.resetRoom(room);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GMApi#resetRoom");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
GMApi *apiInstance = [[GMApi alloc] init];
String *room = galactic; // Name of room to use. (default to null)

// Reset room
[apiInstance resetRoomWith:room
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

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

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.GMApi()
var room = galactic; // {String} Name of room to use.

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

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

namespace Example
{
    public class resetRoomExample
    {
        public void main()
        {
            // Configure API key authorization: UserAuth
            Configuration.Default.ApiKey.Add("X-Assassin-User", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-Assassin-User", "Bearer");
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new GMApi();
            var room = galactic;  // String | Name of room to use. (default to null)

            try {
                // Reset room
                putRoom_200_response result = apiInstance.resetRoom(room);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GMApi.resetRoom: " + e.Message );
            }
        }
    }
}

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

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GMApi();
$room = galactic; // String | Name of room to use.

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

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GMApi->new();
my $room = galactic; # String | Name of room to use.

eval {
    my $result = $api_instance->resetRoom(room => $room);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GMApi->resetRoom: $@\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: UserAuth
openapi_client.configuration.api_key['X-Assassin-User'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-Assassin-User'] = 'Bearer'

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.GMApi()
room = galactic # String | Name of room to use. (default to null)

try:
    # Reset room
    api_response = api_instance.reset_room(room)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GMApi->resetRoom: %s\n" % e)

extern crate GMApi;

pub fn main() {
    let room = galactic; // String

    let mut context = GMApi::Context::default();
    let result = client.resetRoom(room, &context).wait();

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

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        GMApi apiInstance = new GMApi();
        String room = galactic; // String | Name of room to use.

        try {
            putRoom_200_response result = apiInstance.setGM(room);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GMApi#setGM");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String room = new String(); // String | Name of room to use.

try {
    final result = await api_instance.setGM(room);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->setGM: $e\n');
}

import org.openapitools.client.api.GMApi;

public class GMApiExample {
    public static void main(String[] args) {
        GMApi apiInstance = new GMApi();
        String room = galactic; // String | Name of room to use.

        try {
            putRoom_200_response result = apiInstance.setGM(room);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GMApi#setGM");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
GMApi *apiInstance = [[GMApi alloc] init];
String *room = galactic; // Name of room to use. (default to null)

// Set GM
[apiInstance setGMWith:room
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

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

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.GMApi()
var room = galactic; // {String} Name of room to use.

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

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

namespace Example
{
    public class setGMExample
    {
        public void main()
        {
            // Configure API key authorization: UserAuth
            Configuration.Default.ApiKey.Add("X-Assassin-User", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-Assassin-User", "Bearer");
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new GMApi();
            var room = galactic;  // String | Name of room to use. (default to null)

            try {
                // Set GM
                putRoom_200_response result = apiInstance.setGM(room);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GMApi.setGM: " + e.Message );
            }
        }
    }
}

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

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GMApi();
$room = galactic; // String | Name of room to use.

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

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GMApi->new();
my $room = galactic; # String | Name of room to use.

eval {
    my $result = $api_instance->setGM(room => $room);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GMApi->setGM: $@\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: UserAuth
openapi_client.configuration.api_key['X-Assassin-User'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-Assassin-User'] = 'Bearer'

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.GMApi()
room = galactic # String | Name of room to use. (default to null)

try:
    # Set GM
    api_response = api_instance.set_gm(room)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GMApi->setGM: %s\n" % e)

extern crate GMApi;

pub fn main() {
    let room = galactic; // String

    let mut context = GMApi::Context::default();
    let result = client.setGM(room, &context).wait();

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

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        GMApi apiInstance = new GMApi();
        String room = galactic; // String | Name of room to use.

        try {
            putRoom_200_response result = apiInstance.startRoom(room);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GMApi#startRoom");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String room = new String(); // String | Name of room to use.

try {
    final result = await api_instance.startRoom(room);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->startRoom: $e\n');
}

import org.openapitools.client.api.GMApi;

public class GMApiExample {
    public static void main(String[] args) {
        GMApi apiInstance = new GMApi();
        String room = galactic; // String | Name of room to use.

        try {
            putRoom_200_response result = apiInstance.startRoom(room);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GMApi#startRoom");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
GMApi *apiInstance = [[GMApi alloc] init];
String *room = galactic; // Name of room to use. (default to null)

// Start game
[apiInstance startRoomWith:room
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

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

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.GMApi()
var room = galactic; // {String} Name of room to use.

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

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

namespace Example
{
    public class startRoomExample
    {
        public void main()
        {
            // Configure API key authorization: UserAuth
            Configuration.Default.ApiKey.Add("X-Assassin-User", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-Assassin-User", "Bearer");
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new GMApi();
            var room = galactic;  // String | Name of room to use. (default to null)

            try {
                // Start game
                putRoom_200_response result = apiInstance.startRoom(room);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GMApi.startRoom: " + e.Message );
            }
        }
    }
}

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

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GMApi();
$room = galactic; // String | Name of room to use.

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

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GMApi->new();
my $room = galactic; # String | Name of room to use.

eval {
    my $result = $api_instance->startRoom(room => $room);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GMApi->startRoom: $@\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: UserAuth
openapi_client.configuration.api_key['X-Assassin-User'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-Assassin-User'] = 'Bearer'

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.GMApi()
room = galactic # String | Name of room to use. (default to null)

try:
    # Start game
    api_response = api_instance.start_room(room)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GMApi->startRoom: %s\n" % e)

extern crate GMApi;

pub fn main() {
    let room = galactic; // String

    let mut context = GMApi::Context::default();
    let result = client.startRoom(room, &context).wait();

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

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

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

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

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

        try {
            getDatabase_200_response result = apiInstance.getDatabase();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InfoApi#getDatabase");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.getDatabase();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getDatabase: $e\n');
}

import org.openapitools.client.api.InfoApi;

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

        try {
            getDatabase_200_response result = apiInstance.getDatabase();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InfoApi#getDatabase");
            e.printStackTrace();
        }
    }
}

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

// Get database info
[apiInstance getDatabaseWithCompletionHandler: 
              ^(getDatabase_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');

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

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

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

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

            try {
                // Get database info
                getDatabase_200_response result = apiInstance.getDatabase();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling InfoApi.getDatabase: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->getDatabase();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling InfoApi->getDatabase: $@\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.InfoApi()

try:
    # Get database info
    api_response = api_instance.get_database()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling InfoApi->getDatabase: %s\n" % e)

extern crate InfoApi;

pub fn main() {

    let mut context = InfoApi::Context::default();
    let result = client.getDatabase(&context).wait();

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

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

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

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

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

        try {
            serverInfo_200_response result = apiInstance.serverInfo();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InfoApi#serverInfo");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.serverInfo();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->serverInfo: $e\n');
}

import org.openapitools.client.api.InfoApi;

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

        try {
            serverInfo_200_response result = apiInstance.serverInfo();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling InfoApi#serverInfo");
            e.printStackTrace();
        }
    }
}

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

// Server infromation
[apiInstance serverInfoWithCompletionHandler: 
              ^(serverInfo_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');

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

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

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

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

            try {
                // Server infromation
                serverInfo_200_response result = apiInstance.serverInfo();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling InfoApi.serverInfo: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->serverInfo();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling InfoApi->serverInfo: $@\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.InfoApi()

try:
    # Server infromation
    api_response = api_instance.server_info()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling InfoApi->serverInfo: %s\n" % e)

extern crate InfoApi;

pub fn main() {

    let mut context = InfoApi::Context::default();
    let result = client.serverInfo(&context).wait();

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

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        PlayerApi apiInstance = new PlayerApi();
        String room = galactic; // String | Name of room to use.
        String name = Vlad; // String | Name of player within a room.

        try {
            putRoom_200_response result = apiInstance.deletePlayer(room, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PlayerApi#deletePlayer");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String room = new String(); // String | Name of room to use.
final String name = new String(); // String | Name of player within a room.

try {
    final result = await api_instance.deletePlayer(room, name);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deletePlayer: $e\n');
}

import org.openapitools.client.api.PlayerApi;

public class PlayerApiExample {
    public static void main(String[] args) {
        PlayerApi apiInstance = new PlayerApi();
        String room = galactic; // String | Name of room to use.
        String name = Vlad; // String | Name of player within a room.

        try {
            putRoom_200_response result = apiInstance.deletePlayer(room, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PlayerApi#deletePlayer");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
PlayerApi *apiInstance = [[PlayerApi alloc] init];
String *room = galactic; // Name of room to use. (default to null)
String *name = Vlad; // Name of player within a room. (default to null)

// Delete player
[apiInstance deletePlayerWith:room
    name:name
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

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

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.PlayerApi()
var room = galactic; // {String} Name of room to use.
var name = Vlad; // {String} Name of player within a room.

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

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

namespace Example
{
    public class deletePlayerExample
    {
        public void main()
        {
            // Configure API key authorization: UserAuth
            Configuration.Default.ApiKey.Add("X-Assassin-User", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-Assassin-User", "Bearer");
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new PlayerApi();
            var room = galactic;  // String | Name of room to use. (default to null)
            var name = Vlad;  // String | Name of player within a room. (default to null)

            try {
                // Delete player
                putRoom_200_response result = apiInstance.deletePlayer(room, name);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PlayerApi.deletePlayer: " + e.Message );
            }
        }
    }
}

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

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PlayerApi();
$room = galactic; // String | Name of room to use.
$name = Vlad; // String | Name of player within a room.

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

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PlayerApi->new();
my $room = galactic; # String | Name of room to use.
my $name = Vlad; # String | Name of player within a room.

eval {
    my $result = $api_instance->deletePlayer(room => $room, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PlayerApi->deletePlayer: $@\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: UserAuth
openapi_client.configuration.api_key['X-Assassin-User'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-Assassin-User'] = 'Bearer'

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.PlayerApi()
room = galactic # String | Name of room to use. (default to null)
name = Vlad # String | Name of player within a room. (default to null)

try:
    # Delete player
    api_response = api_instance.delete_player(room, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PlayerApi->deletePlayer: %s\n" % e)

extern crate PlayerApi;

pub fn main() {
    let room = galactic; // String
    let name = Vlad; // String

    let mut context = PlayerApi::Context::default();
    let result = client.deletePlayer(room, name, &context).wait();

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

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

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

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

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

        // Create an instance of the API class
        PlayerApi apiInstance = new PlayerApi();
        String room = galactic; // String | Name of room to use.
        String name = Vlad; // String | Name of player within a room.
        EliminatePlayerRequest eliminatePlayerRequest = ; // EliminatePlayerRequest | 

        try {
            putRoom_200_response result = apiInstance.eliminatePlayer(room, name, eliminatePlayerRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PlayerApi#eliminatePlayer");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String room = new String(); // String | Name of room to use.
final String name = new String(); // String | Name of player within a room.
final EliminatePlayerRequest eliminatePlayerRequest = new EliminatePlayerRequest(); // EliminatePlayerRequest | 

try {
    final result = await api_instance.eliminatePlayer(room, name, eliminatePlayerRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->eliminatePlayer: $e\n');
}

import org.openapitools.client.api.PlayerApi;

public class PlayerApiExample {
    public static void main(String[] args) {
        PlayerApi apiInstance = new PlayerApi();
        String room = galactic; // String | Name of room to use.
        String name = Vlad; // String | Name of player within a room.
        EliminatePlayerRequest eliminatePlayerRequest = ; // EliminatePlayerRequest | 

        try {
            putRoom_200_response result = apiInstance.eliminatePlayer(room, name, eliminatePlayerRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PlayerApi#eliminatePlayer");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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


// Create an instance of the API class
PlayerApi *apiInstance = [[PlayerApi alloc] init];
String *room = galactic; // Name of room to use. (default to null)
String *name = Vlad; // Name of player within a room. (default to null)
EliminatePlayerRequest *eliminatePlayerRequest = ; //  (optional)

// Eliminate target
[apiInstance eliminatePlayerWith:room
    name:name
    eliminatePlayerRequest:eliminatePlayerRequest
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new WordAssassinApi.PlayerApi()
var room = galactic; // {String} Name of room to use.
var name = Vlad; // {String} Name of player within a room.
var opts = {
  'eliminatePlayerRequest':  // {EliminatePlayerRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new PlayerApi();
            var room = galactic;  // String | Name of room to use. (default to null)
            var name = Vlad;  // String | Name of player within a room. (default to null)
            var eliminatePlayerRequest = new EliminatePlayerRequest(); // EliminatePlayerRequest |  (optional) 

            try {
                // Eliminate target
                putRoom_200_response result = apiInstance.eliminatePlayer(room, name, eliminatePlayerRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PlayerApi.eliminatePlayer: " + e.Message );
            }
        }
    }
}

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PlayerApi();
$room = galactic; // String | Name of room to use.
$name = Vlad; // String | Name of player within a room.
$eliminatePlayerRequest = ; // EliminatePlayerRequest | 

try {
    $result = $api_instance->eliminatePlayer($room, $name, $eliminatePlayerRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PlayerApi->eliminatePlayer: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PlayerApi->new();
my $room = galactic; # String | Name of room to use.
my $name = Vlad; # String | Name of player within a room.
my $eliminatePlayerRequest = WWW::OPenAPIClient::Object::EliminatePlayerRequest->new(); # EliminatePlayerRequest | 

eval {
    my $result = $api_instance->eliminatePlayer(room => $room, name => $name, eliminatePlayerRequest => $eliminatePlayerRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PlayerApi->eliminatePlayer: $@\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: UserAuth
openapi_client.configuration.api_key['X-Assassin-User'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-Assassin-User'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.PlayerApi()
room = galactic # String | Name of room to use. (default to null)
name = Vlad # String | Name of player within a room. (default to null)
eliminatePlayerRequest =  # EliminatePlayerRequest |  (optional)

try:
    # Eliminate target
    api_response = api_instance.eliminate_player(room, name, eliminatePlayerRequest=eliminatePlayerRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PlayerApi->eliminatePlayer: %s\n" % e)

extern crate PlayerApi;

pub fn main() {
    let room = galactic; // String
    let name = Vlad; // String
    let eliminatePlayerRequest = ; // EliminatePlayerRequest

    let mut context = PlayerApi::Context::default();
    let result = client.eliminatePlayer(room, name, eliminatePlayerRequest, &context).wait();

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

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        PlayerApi apiInstance = new PlayerApi();
        String room = galactic; // String | Name of room to use.
        String name = Vlad; // String | Name of player within a room.

        try {
            Player result = apiInstance.getPlayer(room, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PlayerApi#getPlayer");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String room = new String(); // String | Name of room to use.
final String name = new String(); // String | Name of player within a room.

try {
    final result = await api_instance.getPlayer(room, name);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getPlayer: $e\n');
}

import org.openapitools.client.api.PlayerApi;

public class PlayerApiExample {
    public static void main(String[] args) {
        PlayerApi apiInstance = new PlayerApi();
        String room = galactic; // String | Name of room to use.
        String name = Vlad; // String | Name of player within a room.

        try {
            Player result = apiInstance.getPlayer(room, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PlayerApi#getPlayer");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
PlayerApi *apiInstance = [[PlayerApi alloc] init];
String *room = galactic; // Name of room to use. (default to null)
String *name = Vlad; // Name of player within a room. (default to null)

// Get player
[apiInstance getPlayerWith:room
    name:name
              completionHandler: ^(Player output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

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

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.PlayerApi()
var room = galactic; // {String} Name of room to use.
var name = Vlad; // {String} Name of player within a room.

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

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

namespace Example
{
    public class getPlayerExample
    {
        public void main()
        {
            // Configure API key authorization: UserAuth
            Configuration.Default.ApiKey.Add("X-Assassin-User", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-Assassin-User", "Bearer");
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new PlayerApi();
            var room = galactic;  // String | Name of room to use. (default to null)
            var name = Vlad;  // String | Name of player within a room. (default to null)

            try {
                // Get player
                Player result = apiInstance.getPlayer(room, name);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PlayerApi.getPlayer: " + e.Message );
            }
        }
    }
}

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

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PlayerApi();
$room = galactic; // String | Name of room to use.
$name = Vlad; // String | Name of player within a room.

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

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PlayerApi->new();
my $room = galactic; # String | Name of room to use.
my $name = Vlad; # String | Name of player within a room.

eval {
    my $result = $api_instance->getPlayer(room => $room, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PlayerApi->getPlayer: $@\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: UserAuth
openapi_client.configuration.api_key['X-Assassin-User'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-Assassin-User'] = 'Bearer'

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.PlayerApi()
room = galactic # String | Name of room to use. (default to null)
name = Vlad # String | Name of player within a room. (default to null)

try:
    # Get player
    api_response = api_instance.get_player(room, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PlayerApi->getPlayer: %s\n" % e)

extern crate PlayerApi;

pub fn main() {
    let room = galactic; // String
    let name = Vlad; // String

    let mut context = PlayerApi::Context::default();
    let result = client.getPlayer(room, name, &context).wait();

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

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        PlayerApi apiInstance = new PlayerApi();
        String room = galactic; // String | Name of room to use.
        String name = Vlad; // String | Name of player within a room.

        try {
            putRoom_200_response result = apiInstance.putPlayer(room, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PlayerApi#putPlayer");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String room = new String(); // String | Name of room to use.
final String name = new String(); // String | Name of player within a room.

try {
    final result = await api_instance.putPlayer(room, name);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->putPlayer: $e\n');
}

import org.openapitools.client.api.PlayerApi;

public class PlayerApiExample {
    public static void main(String[] args) {
        PlayerApi apiInstance = new PlayerApi();
        String room = galactic; // String | Name of room to use.
        String name = Vlad; // String | Name of player within a room.

        try {
            putRoom_200_response result = apiInstance.putPlayer(room, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PlayerApi#putPlayer");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
PlayerApi *apiInstance = [[PlayerApi alloc] init];
String *room = galactic; // Name of room to use. (default to null)
String *name = Vlad; // Name of player within a room. (default to null)

// Add player
[apiInstance putPlayerWith:room
    name:name
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

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

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.PlayerApi()
var room = galactic; // {String} Name of room to use.
var name = Vlad; // {String} Name of player within a room.

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

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

namespace Example
{
    public class putPlayerExample
    {
        public void main()
        {
            // Configure API key authorization: UserAuth
            Configuration.Default.ApiKey.Add("X-Assassin-User", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-Assassin-User", "Bearer");
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new PlayerApi();
            var room = galactic;  // String | Name of room to use. (default to null)
            var name = Vlad;  // String | Name of player within a room. (default to null)

            try {
                // Add player
                putRoom_200_response result = apiInstance.putPlayer(room, name);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PlayerApi.putPlayer: " + e.Message );
            }
        }
    }
}

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

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PlayerApi();
$room = galactic; // String | Name of room to use.
$name = Vlad; // String | Name of player within a room.

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

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PlayerApi->new();
my $room = galactic; # String | Name of room to use.
my $name = Vlad; # String | Name of player within a room.

eval {
    my $result = $api_instance->putPlayer(room => $room, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PlayerApi->putPlayer: $@\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: UserAuth
openapi_client.configuration.api_key['X-Assassin-User'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-Assassin-User'] = 'Bearer'

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.PlayerApi()
room = galactic # String | Name of room to use. (default to null)
name = Vlad # String | Name of player within a room. (default to null)

try:
    # Add player
    api_response = api_instance.put_player(room, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PlayerApi->putPlayer: %s\n" % e)

extern crate PlayerApi;

pub fn main() {
    let room = galactic; // String
    let name = Vlad; // String

    let mut context = PlayerApi::Context::default();
    let result = client.putPlayer(room, name, &context).wait();

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

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RoomApi apiInstance = new RoomApi();
        String room = galactic; // String | Name of room to use.

        try {
            putRoom_200_response result = apiInstance.assignGM(room);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RoomApi#assignGM");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String room = new String(); // String | Name of room to use.

try {
    final result = await api_instance.assignGM(room);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->assignGM: $e\n');
}

import org.openapitools.client.api.RoomApi;

public class RoomApiExample {
    public static void main(String[] args) {
        RoomApi apiInstance = new RoomApi();
        String room = galactic; // String | Name of room to use.

        try {
            putRoom_200_response result = apiInstance.assignGM(room);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RoomApi#assignGM");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RoomApi *apiInstance = [[RoomApi alloc] init];
String *room = galactic; // Name of room to use. (default to null)

// Randomly assign GM
[apiInstance assignGMWith:room
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

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

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.RoomApi()
var room = galactic; // {String} Name of room to use.

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

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

namespace Example
{
    public class assignGMExample
    {
        public void main()
        {
            // Configure API key authorization: UserAuth
            Configuration.Default.ApiKey.Add("X-Assassin-User", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-Assassin-User", "Bearer");
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RoomApi();
            var room = galactic;  // String | Name of room to use. (default to null)

            try {
                // Randomly assign GM
                putRoom_200_response result = apiInstance.assignGM(room);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RoomApi.assignGM: " + e.Message );
            }
        }
    }
}

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

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RoomApi();
$room = galactic; // String | Name of room to use.

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

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RoomApi->new();
my $room = galactic; # String | Name of room to use.

eval {
    my $result = $api_instance->assignGM(room => $room);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RoomApi->assignGM: $@\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: UserAuth
openapi_client.configuration.api_key['X-Assassin-User'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-Assassin-User'] = 'Bearer'

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RoomApi()
room = galactic # String | Name of room to use. (default to null)

try:
    # Randomly assign GM
    api_response = api_instance.assign_gm(room)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RoomApi->assignGM: %s\n" % e)

extern crate RoomApi;

pub fn main() {
    let room = galactic; // String

    let mut context = RoomApi::Context::default();
    let result = client.assignGM(room, &context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RoomApi apiInstance = new RoomApi();
        String room = galactic; // String | Name of room to use.

        try {
            putRoom_200_response result = apiInstance.deleteRoom(room);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RoomApi#deleteRoom");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String room = new String(); // String | Name of room to use.

try {
    final result = await api_instance.deleteRoom(room);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteRoom: $e\n');
}

import org.openapitools.client.api.RoomApi;

public class RoomApiExample {
    public static void main(String[] args) {
        RoomApi apiInstance = new RoomApi();
        String room = galactic; // String | Name of room to use.

        try {
            putRoom_200_response result = apiInstance.deleteRoom(room);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RoomApi#deleteRoom");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RoomApi *apiInstance = [[RoomApi alloc] init];
String *room = galactic; // Name of room to use. (default to null)

// Delete room
[apiInstance deleteRoomWith:room
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.RoomApi()
var room = galactic; // {String} Name of room to use.

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

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

namespace Example
{
    public class deleteRoomExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RoomApi();
            var room = galactic;  // String | Name of room to use. (default to null)

            try {
                // Delete room
                putRoom_200_response result = apiInstance.deleteRoom(room);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RoomApi.deleteRoom: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RoomApi();
$room = galactic; // String | Name of room to use.

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RoomApi->new();
my $room = galactic; # String | Name of room to use.

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

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RoomApi()
room = galactic # String | Name of room to use. (default to null)

try:
    # Delete room
    api_response = api_instance.delete_room(room)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RoomApi->deleteRoom: %s\n" % e)

extern crate RoomApi;

pub fn main() {
    let room = galactic; // String

    let mut context = RoomApi::Context::default();
    let result = client.deleteRoom(room, &context).wait();

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

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

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

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

        // Create an instance of the API class
        RoomApi apiInstance = new RoomApi();
        String room = galactic; // String | Name of room to use.

        try {
            Room result = apiInstance.getRoom(room);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RoomApi#getRoom");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String room = new String(); // String | Name of room to use.

try {
    final result = await api_instance.getRoom(room);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getRoom: $e\n');
}

import org.openapitools.client.api.RoomApi;

public class RoomApiExample {
    public static void main(String[] args) {
        RoomApi apiInstance = new RoomApi();
        String room = galactic; // String | Name of room to use.

        try {
            Room result = apiInstance.getRoom(room);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RoomApi#getRoom");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
RoomApi *apiInstance = [[RoomApi alloc] init];
String *room = galactic; // Name of room to use. (default to null)

// Get room
[apiInstance getRoomWith:room
              completionHandler: ^(Room output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');

// Create an instance of the API class
var api = new WordAssassinApi.RoomApi()
var room = galactic; // {String} Name of room to use.

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

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

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

            // Create an instance of the API class
            var apiInstance = new RoomApi();
            var room = galactic;  // String | Name of room to use. (default to null)

            try {
                // Get room
                Room result = apiInstance.getRoom(room);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RoomApi.getRoom: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RoomApi();
$room = galactic; // String | Name of room to use.

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RoomApi->new();
my $room = galactic; # String | Name of room to use.

eval {
    my $result = $api_instance->getRoom(room => $room);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RoomApi->getRoom: $@\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.RoomApi()
room = galactic # String | Name of room to use. (default to null)

try:
    # Get room
    api_response = api_instance.get_room(room)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RoomApi->getRoom: %s\n" % e)

extern crate RoomApi;

pub fn main() {
    let room = galactic; // String

    let mut context = RoomApi::Context::default();
    let result = client.getRoom(room, &context).wait();

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

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

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

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

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

        try {
            listRooms_200_response result = apiInstance.listRooms();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RoomApi#listRooms");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.listRooms();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listRooms: $e\n');
}

import org.openapitools.client.api.RoomApi;

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

        try {
            listRooms_200_response result = apiInstance.listRooms();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RoomApi#listRooms");
            e.printStackTrace();
        }
    }
}

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

// List rooms
[apiInstance listRoomsWithCompletionHandler: 
              ^(listRooms_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');

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

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

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

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

            try {
                // List rooms
                listRooms_200_response result = apiInstance.listRooms();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RoomApi.listRooms: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->listRooms();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RoomApi->listRooms: $@\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.RoomApi()

try:
    # List rooms
    api_response = api_instance.list_rooms()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RoomApi->listRooms: %s\n" % e)

extern crate RoomApi;

pub fn main() {

    let mut context = RoomApi::Context::default();
    let result = client.listRooms(&context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RoomApi apiInstance = new RoomApi();
        String room = galactic; // String | Name of room to use.
        UpdateRoomBody updateRoomBody = ; // UpdateRoomBody | 

        try {
            putRoom_200_response result = apiInstance.patchRoom(room, updateRoomBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RoomApi#patchRoom");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String room = new String(); // String | Name of room to use.
final UpdateRoomBody updateRoomBody = new UpdateRoomBody(); // UpdateRoomBody | 

try {
    final result = await api_instance.patchRoom(room, updateRoomBody);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->patchRoom: $e\n');
}

import org.openapitools.client.api.RoomApi;

public class RoomApiExample {
    public static void main(String[] args) {
        RoomApi apiInstance = new RoomApi();
        String room = galactic; // String | Name of room to use.
        UpdateRoomBody updateRoomBody = ; // UpdateRoomBody | 

        try {
            putRoom_200_response result = apiInstance.patchRoom(room, updateRoomBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RoomApi#patchRoom");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RoomApi *apiInstance = [[RoomApi alloc] init];
String *room = galactic; // Name of room to use. (default to null)
UpdateRoomBody *updateRoomBody = ; //  (optional)

// Update room
[apiInstance patchRoomWith:room
    updateRoomBody:updateRoomBody
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.RoomApi()
var room = galactic; // {String} Name of room to use.
var opts = {
  'updateRoomBody':  // {UpdateRoomBody} 
};

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

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

namespace Example
{
    public class patchRoomExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RoomApi();
            var room = galactic;  // String | Name of room to use. (default to null)
            var updateRoomBody = new UpdateRoomBody(); // UpdateRoomBody |  (optional) 

            try {
                // Update room
                putRoom_200_response result = apiInstance.patchRoom(room, updateRoomBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RoomApi.patchRoom: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RoomApi();
$room = galactic; // String | Name of room to use.
$updateRoomBody = ; // UpdateRoomBody | 

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RoomApi->new();
my $room = galactic; # String | Name of room to use.
my $updateRoomBody = WWW::OPenAPIClient::Object::UpdateRoomBody->new(); # UpdateRoomBody | 

eval {
    my $result = $api_instance->patchRoom(room => $room, updateRoomBody => $updateRoomBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RoomApi->patchRoom: $@\n";
}

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RoomApi()
room = galactic # String | Name of room to use. (default to null)
updateRoomBody =  # UpdateRoomBody |  (optional)

try:
    # Update room
    api_response = api_instance.patch_room(room, updateRoomBody=updateRoomBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RoomApi->patchRoom: %s\n" % e)

extern crate RoomApi;

pub fn main() {
    let room = galactic; // String
    let updateRoomBody = ; // UpdateRoomBody

    let mut context = RoomApi::Context::default();
    let result = client.patchRoom(room, updateRoomBody, &context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RoomApi apiInstance = new RoomApi();
        String room = galactic; // String | Name of room to use.
        AddRoomBody addRoomBody = ; // AddRoomBody | 

        try {
            putRoom_200_response result = apiInstance.putRoom(room, addRoomBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RoomApi#putRoom");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String room = new String(); // String | Name of room to use.
final AddRoomBody addRoomBody = new AddRoomBody(); // AddRoomBody | 

try {
    final result = await api_instance.putRoom(room, addRoomBody);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->putRoom: $e\n');
}

import org.openapitools.client.api.RoomApi;

public class RoomApiExample {
    public static void main(String[] args) {
        RoomApi apiInstance = new RoomApi();
        String room = galactic; // String | Name of room to use.
        AddRoomBody addRoomBody = ; // AddRoomBody | 

        try {
            putRoom_200_response result = apiInstance.putRoom(room, addRoomBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RoomApi#putRoom");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RoomApi *apiInstance = [[RoomApi alloc] init];
String *room = galactic; // Name of room to use. (default to null)
AddRoomBody *addRoomBody = ; //  (optional)

// Add room
[apiInstance putRoomWith:room
    addRoomBody:addRoomBody
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.RoomApi()
var room = galactic; // {String} Name of room to use.
var opts = {
  'addRoomBody':  // {AddRoomBody} 
};

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

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

namespace Example
{
    public class putRoomExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RoomApi();
            var room = galactic;  // String | Name of room to use. (default to null)
            var addRoomBody = new AddRoomBody(); // AddRoomBody |  (optional) 

            try {
                // Add room
                putRoom_200_response result = apiInstance.putRoom(room, addRoomBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RoomApi.putRoom: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RoomApi();
$room = galactic; // String | Name of room to use.
$addRoomBody = ; // AddRoomBody | 

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RoomApi->new();
my $room = galactic; # String | Name of room to use.
my $addRoomBody = WWW::OPenAPIClient::Object::AddRoomBody->new(); # AddRoomBody | 

eval {
    my $result = $api_instance->putRoom(room => $room, addRoomBody => $addRoomBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RoomApi->putRoom: $@\n";
}

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RoomApi()
room = galactic # String | Name of room to use. (default to null)
addRoomBody =  # AddRoomBody |  (optional)

try:
    # Add room
    api_response = api_instance.put_room(room, addRoomBody=addRoomBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RoomApi->putRoom: %s\n" % e)

extern crate RoomApi;

pub fn main() {
    let room = galactic; // String
    let addRoomBody = ; // AddRoomBody

    let mut context = RoomApi::Context::default();
    let result = client.putRoom(room, addRoomBody, &context).wait();

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

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RoomApi apiInstance = new RoomApi();
        String room = galactic; // String | Name of room to use.

        try {
            putRoom_200_response result = apiInstance.resetRoom(room);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RoomApi#resetRoom");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String room = new String(); // String | Name of room to use.

try {
    final result = await api_instance.resetRoom(room);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->resetRoom: $e\n');
}

import org.openapitools.client.api.RoomApi;

public class RoomApiExample {
    public static void main(String[] args) {
        RoomApi apiInstance = new RoomApi();
        String room = galactic; // String | Name of room to use.

        try {
            putRoom_200_response result = apiInstance.resetRoom(room);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RoomApi#resetRoom");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RoomApi *apiInstance = [[RoomApi alloc] init];
String *room = galactic; // Name of room to use. (default to null)

// Reset room
[apiInstance resetRoomWith:room
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

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

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.RoomApi()
var room = galactic; // {String} Name of room to use.

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

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

namespace Example
{
    public class resetRoomExample
    {
        public void main()
        {
            // Configure API key authorization: UserAuth
            Configuration.Default.ApiKey.Add("X-Assassin-User", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-Assassin-User", "Bearer");
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RoomApi();
            var room = galactic;  // String | Name of room to use. (default to null)

            try {
                // Reset room
                putRoom_200_response result = apiInstance.resetRoom(room);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RoomApi.resetRoom: " + e.Message );
            }
        }
    }
}

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

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RoomApi();
$room = galactic; // String | Name of room to use.

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

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RoomApi->new();
my $room = galactic; # String | Name of room to use.

eval {
    my $result = $api_instance->resetRoom(room => $room);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RoomApi->resetRoom: $@\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: UserAuth
openapi_client.configuration.api_key['X-Assassin-User'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-Assassin-User'] = 'Bearer'

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RoomApi()
room = galactic # String | Name of room to use. (default to null)

try:
    # Reset room
    api_response = api_instance.reset_room(room)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RoomApi->resetRoom: %s\n" % e)

extern crate RoomApi;

pub fn main() {
    let room = galactic; // String

    let mut context = RoomApi::Context::default();
    let result = client.resetRoom(room, &context).wait();

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

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RoomApi apiInstance = new RoomApi();
        String room = galactic; // String | Name of room to use.

        try {
            putRoom_200_response result = apiInstance.setGM(room);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RoomApi#setGM");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String room = new String(); // String | Name of room to use.

try {
    final result = await api_instance.setGM(room);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->setGM: $e\n');
}

import org.openapitools.client.api.RoomApi;

public class RoomApiExample {
    public static void main(String[] args) {
        RoomApi apiInstance = new RoomApi();
        String room = galactic; // String | Name of room to use.

        try {
            putRoom_200_response result = apiInstance.setGM(room);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RoomApi#setGM");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RoomApi *apiInstance = [[RoomApi alloc] init];
String *room = galactic; // Name of room to use. (default to null)

// Set GM
[apiInstance setGMWith:room
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

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

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.RoomApi()
var room = galactic; // {String} Name of room to use.

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

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

namespace Example
{
    public class setGMExample
    {
        public void main()
        {
            // Configure API key authorization: UserAuth
            Configuration.Default.ApiKey.Add("X-Assassin-User", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-Assassin-User", "Bearer");
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RoomApi();
            var room = galactic;  // String | Name of room to use. (default to null)

            try {
                // Set GM
                putRoom_200_response result = apiInstance.setGM(room);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RoomApi.setGM: " + e.Message );
            }
        }
    }
}

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

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RoomApi();
$room = galactic; // String | Name of room to use.

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

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RoomApi->new();
my $room = galactic; # String | Name of room to use.

eval {
    my $result = $api_instance->setGM(room => $room);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RoomApi->setGM: $@\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: UserAuth
openapi_client.configuration.api_key['X-Assassin-User'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-Assassin-User'] = 'Bearer'

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RoomApi()
room = galactic # String | Name of room to use. (default to null)

try:
    # Set GM
    api_response = api_instance.set_gm(room)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RoomApi->setGM: %s\n" % e)

extern crate RoomApi;

pub fn main() {
    let room = galactic; // String

    let mut context = RoomApi::Context::default();
    let result = client.setGM(room, &context).wait();

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

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RoomApi apiInstance = new RoomApi();
        String room = galactic; // String | Name of room to use.

        try {
            putRoom_200_response result = apiInstance.startRoom(room);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RoomApi#startRoom");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String room = new String(); // String | Name of room to use.

try {
    final result = await api_instance.startRoom(room);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->startRoom: $e\n');
}

import org.openapitools.client.api.RoomApi;

public class RoomApiExample {
    public static void main(String[] args) {
        RoomApi apiInstance = new RoomApi();
        String room = galactic; // String | Name of room to use.

        try {
            putRoom_200_response result = apiInstance.startRoom(room);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RoomApi#startRoom");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
RoomApi *apiInstance = [[RoomApi alloc] init];
String *room = galactic; // Name of room to use. (default to null)

// Start game
[apiInstance startRoomWith:room
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

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

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.RoomApi()
var room = galactic; // {String} Name of room to use.

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

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

namespace Example
{
    public class startRoomExample
    {
        public void main()
        {
            // Configure API key authorization: UserAuth
            Configuration.Default.ApiKey.Add("X-Assassin-User", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-Assassin-User", "Bearer");
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RoomApi();
            var room = galactic;  // String | Name of room to use. (default to null)

            try {
                // Start game
                putRoom_200_response result = apiInstance.startRoom(room);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RoomApi.startRoom: " + e.Message );
            }
        }
    }
}

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

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RoomApi();
$room = galactic; // String | Name of room to use.

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

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RoomApi->new();
my $room = galactic; # String | Name of room to use.

eval {
    my $result = $api_instance->startRoom(room => $room);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RoomApi->startRoom: $@\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: UserAuth
openapi_client.configuration.api_key['X-Assassin-User'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-Assassin-User'] = 'Bearer'

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RoomApi()
room = galactic # String | Name of room to use. (default to null)

try:
    # Start game
    api_response = api_instance.start_room(room)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RoomApi->startRoom: %s\n" % e)

extern crate RoomApi;

pub fn main() {
    let room = galactic; // String

    let mut context = RoomApi::Context::default();
    let result = client.startRoom(room, &context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.checkWordLists();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->checkWordLists: $e\n');
}

import org.openapitools.client.api.WordlistApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

// Check importable wordlists.
[apiInstance checkWordListsWithCompletionHandler: 
              ^(array[ImportableWordList] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

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

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

namespace Example
{
    public class checkWordListsExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Check importable wordlists.
                array[ImportableWordList] result = apiInstance.checkWordLists();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling WordlistApi.checkWordLists: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Check importable wordlists.
    api_response = api_instance.check_word_lists()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WordlistApi->checkWordLists: %s\n" % e)

extern crate WordlistApi;

pub fn main() {

    let mut context = WordlistApi::Context::default();
    let result = client.checkWordLists(&context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        WordlistApi apiInstance = new WordlistApi();
        String list = card-poison; // String | Name of word list to use.
        String word = test; // String | Word to add/delete.

        try {
            putRoom_200_response result = apiInstance.deleteWord(list, word);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WordlistApi#deleteWord");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String list = new String(); // String | Name of word list to use.
final String word = new String(); // String | Word to add/delete.

try {
    final result = await api_instance.deleteWord(list, word);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteWord: $e\n');
}

import org.openapitools.client.api.WordlistApi;

public class WordlistApiExample {
    public static void main(String[] args) {
        WordlistApi apiInstance = new WordlistApi();
        String list = card-poison; // String | Name of word list to use.
        String word = test; // String | Word to add/delete.

        try {
            putRoom_200_response result = apiInstance.deleteWord(list, word);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WordlistApi#deleteWord");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
WordlistApi *apiInstance = [[WordlistApi alloc] init];
String *list = card-poison; // Name of word list to use. (default to null)
String *word = test; // Word to add/delete. (default to null)

// Delete word from wordlist
[apiInstance deleteWordWith:list
    word:word
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.WordlistApi()
var list = card-poison; // {String} Name of word list to use.
var word = test; // {String} Word to add/delete.

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

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

namespace Example
{
    public class deleteWordExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new WordlistApi();
            var list = card-poison;  // String | Name of word list to use. (default to null)
            var word = test;  // String | Word to add/delete. (default to null)

            try {
                // Delete word from wordlist
                putRoom_200_response result = apiInstance.deleteWord(list, word);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling WordlistApi.deleteWord: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\WordlistApi();
$list = card-poison; // String | Name of word list to use.
$word = test; // String | Word to add/delete.

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::WordlistApi->new();
my $list = card-poison; # String | Name of word list to use.
my $word = test; # String | Word to add/delete.

eval {
    my $result = $api_instance->deleteWord(list => $list, word => $word);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WordlistApi->deleteWord: $@\n";
}

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.WordlistApi()
list = card-poison # String | Name of word list to use. (default to null)
word = test # String | Word to add/delete. (default to null)

try:
    # Delete word from wordlist
    api_response = api_instance.delete_word(list, word)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WordlistApi->deleteWord: %s\n" % e)

extern crate WordlistApi;

pub fn main() {
    let list = card-poison; // String
    let word = test; // String

    let mut context = WordlistApi::Context::default();
    let result = client.deleteWord(list, word, &context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        WordlistApi apiInstance = new WordlistApi();
        String list = card-poison; // String | Name of word list to use.

        try {
            putRoom_200_response result = apiInstance.deleteWordList(list);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WordlistApi#deleteWordList");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String list = new String(); // String | Name of word list to use.

try {
    final result = await api_instance.deleteWordList(list);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteWordList: $e\n');
}

import org.openapitools.client.api.WordlistApi;

public class WordlistApiExample {
    public static void main(String[] args) {
        WordlistApi apiInstance = new WordlistApi();
        String list = card-poison; // String | Name of word list to use.

        try {
            putRoom_200_response result = apiInstance.deleteWordList(list);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WordlistApi#deleteWordList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
WordlistApi *apiInstance = [[WordlistApi alloc] init];
String *list = card-poison; // Name of word list to use. (default to null)

// Delete wordlist
[apiInstance deleteWordListWith:list
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.WordlistApi()
var list = card-poison; // {String} Name of word list to use.

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

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

namespace Example
{
    public class deleteWordListExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new WordlistApi();
            var list = card-poison;  // String | Name of word list to use. (default to null)

            try {
                // Delete wordlist
                putRoom_200_response result = apiInstance.deleteWordList(list);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling WordlistApi.deleteWordList: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\WordlistApi();
$list = card-poison; // String | Name of word list to use.

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::WordlistApi->new();
my $list = card-poison; # String | Name of word list to use.

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

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.WordlistApi()
list = card-poison # String | Name of word list to use. (default to null)

try:
    # Delete wordlist
    api_response = api_instance.delete_word_list(list)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WordlistApi->deleteWordList: %s\n" % e)

extern crate WordlistApi;

pub fn main() {
    let list = card-poison; // String

    let mut context = WordlistApi::Context::default();
    let result = client.deleteWordList(list, &context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        WordlistApi apiInstance = new WordlistApi();
        String list = card-poison; // String | Name of word list to use.
        WordsBody wordsBody = ; // WordsBody | 

        try {
            putRoom_200_response result = apiInstance.deleteWords(list, wordsBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WordlistApi#deleteWords");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String list = new String(); // String | Name of word list to use.
final WordsBody wordsBody = new WordsBody(); // WordsBody | 

try {
    final result = await api_instance.deleteWords(list, wordsBody);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteWords: $e\n');
}

import org.openapitools.client.api.WordlistApi;

public class WordlistApiExample {
    public static void main(String[] args) {
        WordlistApi apiInstance = new WordlistApi();
        String list = card-poison; // String | Name of word list to use.
        WordsBody wordsBody = ; // WordsBody | 

        try {
            putRoom_200_response result = apiInstance.deleteWords(list, wordsBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WordlistApi#deleteWords");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
WordlistApi *apiInstance = [[WordlistApi alloc] init];
String *list = card-poison; // Name of word list to use. (default to null)
WordsBody *wordsBody = ; //  (optional)

// Delete words from wordlist
[apiInstance deleteWordsWith:list
    wordsBody:wordsBody
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.WordlistApi()
var list = card-poison; // {String} Name of word list to use.
var opts = {
  'wordsBody':  // {WordsBody} 
};

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

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

namespace Example
{
    public class deleteWordsExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new WordlistApi();
            var list = card-poison;  // String | Name of word list to use. (default to null)
            var wordsBody = new WordsBody(); // WordsBody |  (optional) 

            try {
                // Delete words from wordlist
                putRoom_200_response result = apiInstance.deleteWords(list, wordsBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling WordlistApi.deleteWords: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\WordlistApi();
$list = card-poison; // String | Name of word list to use.
$wordsBody = ; // WordsBody | 

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::WordlistApi->new();
my $list = card-poison; # String | Name of word list to use.
my $wordsBody = WWW::OPenAPIClient::Object::WordsBody->new(); # WordsBody | 

eval {
    my $result = $api_instance->deleteWords(list => $list, wordsBody => $wordsBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WordlistApi->deleteWords: $@\n";
}

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.WordlistApi()
list = card-poison # String | Name of word list to use. (default to null)
wordsBody =  # WordsBody |  (optional)

try:
    # Delete words from wordlist
    api_response = api_instance.delete_words(list, wordsBody=wordsBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WordlistApi->deleteWords: %s\n" % e)

extern crate WordlistApi;

pub fn main() {
    let list = card-poison; // String
    let wordsBody = ; // WordsBody

    let mut context = WordlistApi::Context::default();
    let result = client.deleteWords(list, wordsBody, &context).wait();

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

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

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

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

        // Create an instance of the API class
        WordlistApi apiInstance = new WordlistApi();
        String list = card-poison; // String | Name of word list to use.

        try {
            Wordlist result = apiInstance.getWordList(list);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WordlistApi#getWordList");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String list = new String(); // String | Name of word list to use.

try {
    final result = await api_instance.getWordList(list);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getWordList: $e\n');
}

import org.openapitools.client.api.WordlistApi;

public class WordlistApiExample {
    public static void main(String[] args) {
        WordlistApi apiInstance = new WordlistApi();
        String list = card-poison; // String | Name of word list to use.

        try {
            Wordlist result = apiInstance.getWordList(list);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WordlistApi#getWordList");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
WordlistApi *apiInstance = [[WordlistApi alloc] init];
String *list = card-poison; // Name of word list to use. (default to null)

// Get wordlist
[apiInstance getWordListWith:list
              completionHandler: ^(Wordlist output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');

// Create an instance of the API class
var api = new WordAssassinApi.WordlistApi()
var list = card-poison; // {String} Name of word list to use.

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

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

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

            // Create an instance of the API class
            var apiInstance = new WordlistApi();
            var list = card-poison;  // String | Name of word list to use. (default to null)

            try {
                // Get wordlist
                Wordlist result = apiInstance.getWordList(list);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling WordlistApi.getWordList: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\WordlistApi();
$list = card-poison; // String | Name of word list to use.

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::WordlistApi->new();
my $list = card-poison; # String | Name of word list to use.

eval {
    my $result = $api_instance->getWordList(list => $list);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WordlistApi->getWordList: $@\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.WordlistApi()
list = card-poison # String | Name of word list to use. (default to null)

try:
    # Get wordlist
    api_response = api_instance.get_word_list(list)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WordlistApi->getWordList: %s\n" % e)

extern crate WordlistApi;

pub fn main() {
    let list = card-poison; // String

    let mut context = WordlistApi::Context::default();
    let result = client.getWordList(list, &context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        WordlistApi apiInstance = new WordlistApi();
        String list = card-poison; // String | Name of word list to use.

        try {
            putRoom_200_response result = apiInstance.importWordList(list);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WordlistApi#importWordList");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String list = new String(); // String | Name of word list to use.

try {
    final result = await api_instance.importWordList(list);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->importWordList: $e\n');
}

import org.openapitools.client.api.WordlistApi;

public class WordlistApiExample {
    public static void main(String[] args) {
        WordlistApi apiInstance = new WordlistApi();
        String list = card-poison; // String | Name of word list to use.

        try {
            putRoom_200_response result = apiInstance.importWordList(list);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WordlistApi#importWordList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
WordlistApi *apiInstance = [[WordlistApi alloc] init];
String *list = card-poison; // Name of word list to use. (default to null)

// Import or update wordlist.
[apiInstance importWordListWith:list
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.WordlistApi()
var list = card-poison; // {String} Name of word list to use.

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

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

namespace Example
{
    public class importWordListExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new WordlistApi();
            var list = card-poison;  // String | Name of word list to use. (default to null)

            try {
                // Import or update wordlist.
                putRoom_200_response result = apiInstance.importWordList(list);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling WordlistApi.importWordList: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\WordlistApi();
$list = card-poison; // String | Name of word list to use.

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::WordlistApi->new();
my $list = card-poison; # String | Name of word list to use.

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

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.WordlistApi()
list = card-poison # String | Name of word list to use. (default to null)

try:
    # Import or update wordlist.
    api_response = api_instance.import_word_list(list)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WordlistApi->importWordList: %s\n" % e)

extern crate WordlistApi;

pub fn main() {
    let list = card-poison; // String

    let mut context = WordlistApi::Context::default();
    let result = client.importWordList(list, &context).wait();

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

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

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

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

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

        try {
            listWordList_200_response result = apiInstance.listWordList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WordlistApi#listWordList");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.listWordList();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listWordList: $e\n');
}

import org.openapitools.client.api.WordlistApi;

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

        try {
            listWordList_200_response result = apiInstance.listWordList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WordlistApi#listWordList");
            e.printStackTrace();
        }
    }
}

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

// List wordlists
[apiInstance listWordListWithCompletionHandler: 
              ^(listWordList_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');

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

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

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

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

            try {
                // List wordlists
                listWordList_200_response result = apiInstance.listWordList();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling WordlistApi.listWordList: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->listWordList();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WordlistApi->listWordList: $@\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.WordlistApi()

try:
    # List wordlists
    api_response = api_instance.list_word_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WordlistApi->listWordList: %s\n" % e)

extern crate WordlistApi;

pub fn main() {

    let mut context = WordlistApi::Context::default();
    let result = client.listWordList(&context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        WordlistApi apiInstance = new WordlistApi();
        String list = card-poison; // String | Name of word list to use.
        UpdateWordlistBody updateWordlistBody = ; // UpdateWordlistBody | 

        try {
            putRoom_200_response result = apiInstance.patchWordList(list, updateWordlistBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WordlistApi#patchWordList");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String list = new String(); // String | Name of word list to use.
final UpdateWordlistBody updateWordlistBody = new UpdateWordlistBody(); // UpdateWordlistBody | 

try {
    final result = await api_instance.patchWordList(list, updateWordlistBody);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->patchWordList: $e\n');
}

import org.openapitools.client.api.WordlistApi;

public class WordlistApiExample {
    public static void main(String[] args) {
        WordlistApi apiInstance = new WordlistApi();
        String list = card-poison; // String | Name of word list to use.
        UpdateWordlistBody updateWordlistBody = ; // UpdateWordlistBody | 

        try {
            putRoom_200_response result = apiInstance.patchWordList(list, updateWordlistBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WordlistApi#patchWordList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
WordlistApi *apiInstance = [[WordlistApi alloc] init];
String *list = card-poison; // Name of word list to use. (default to null)
UpdateWordlistBody *updateWordlistBody = ; //  (optional)

// Update wordlist
[apiInstance patchWordListWith:list
    updateWordlistBody:updateWordlistBody
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.WordlistApi()
var list = card-poison; // {String} Name of word list to use.
var opts = {
  'updateWordlistBody':  // {UpdateWordlistBody} 
};

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

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

namespace Example
{
    public class patchWordListExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new WordlistApi();
            var list = card-poison;  // String | Name of word list to use. (default to null)
            var updateWordlistBody = new UpdateWordlistBody(); // UpdateWordlistBody |  (optional) 

            try {
                // Update wordlist
                putRoom_200_response result = apiInstance.patchWordList(list, updateWordlistBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling WordlistApi.patchWordList: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\WordlistApi();
$list = card-poison; // String | Name of word list to use.
$updateWordlistBody = ; // UpdateWordlistBody | 

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::WordlistApi->new();
my $list = card-poison; # String | Name of word list to use.
my $updateWordlistBody = WWW::OPenAPIClient::Object::UpdateWordlistBody->new(); # UpdateWordlistBody | 

eval {
    my $result = $api_instance->patchWordList(list => $list, updateWordlistBody => $updateWordlistBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WordlistApi->patchWordList: $@\n";
}

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.WordlistApi()
list = card-poison # String | Name of word list to use. (default to null)
updateWordlistBody =  # UpdateWordlistBody |  (optional)

try:
    # Update wordlist
    api_response = api_instance.patch_word_list(list, updateWordlistBody=updateWordlistBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WordlistApi->patchWordList: %s\n" % e)

extern crate WordlistApi;

pub fn main() {
    let list = card-poison; // String
    let updateWordlistBody = ; // UpdateWordlistBody

    let mut context = WordlistApi::Context::default();
    let result = client.patchWordList(list, updateWordlistBody, &context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        WordlistApi apiInstance = new WordlistApi();
        String list = card-poison; // String | Name of word list to use.
        String word = test; // String | Word to add/delete.

        try {
            putRoom_200_response result = apiInstance.putWord(list, word);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WordlistApi#putWord");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String list = new String(); // String | Name of word list to use.
final String word = new String(); // String | Word to add/delete.

try {
    final result = await api_instance.putWord(list, word);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->putWord: $e\n');
}

import org.openapitools.client.api.WordlistApi;

public class WordlistApiExample {
    public static void main(String[] args) {
        WordlistApi apiInstance = new WordlistApi();
        String list = card-poison; // String | Name of word list to use.
        String word = test; // String | Word to add/delete.

        try {
            putRoom_200_response result = apiInstance.putWord(list, word);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WordlistApi#putWord");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
WordlistApi *apiInstance = [[WordlistApi alloc] init];
String *list = card-poison; // Name of word list to use. (default to null)
String *word = test; // Word to add/delete. (default to null)

// Add word to wordlist
[apiInstance putWordWith:list
    word:word
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.WordlistApi()
var list = card-poison; // {String} Name of word list to use.
var word = test; // {String} Word to add/delete.

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

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

namespace Example
{
    public class putWordExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new WordlistApi();
            var list = card-poison;  // String | Name of word list to use. (default to null)
            var word = test;  // String | Word to add/delete. (default to null)

            try {
                // Add word to wordlist
                putRoom_200_response result = apiInstance.putWord(list, word);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling WordlistApi.putWord: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\WordlistApi();
$list = card-poison; // String | Name of word list to use.
$word = test; // String | Word to add/delete.

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::WordlistApi->new();
my $list = card-poison; # String | Name of word list to use.
my $word = test; # String | Word to add/delete.

eval {
    my $result = $api_instance->putWord(list => $list, word => $word);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WordlistApi->putWord: $@\n";
}

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.WordlistApi()
list = card-poison # String | Name of word list to use. (default to null)
word = test # String | Word to add/delete. (default to null)

try:
    # Add word to wordlist
    api_response = api_instance.put_word(list, word)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WordlistApi->putWord: %s\n" % e)

extern crate WordlistApi;

pub fn main() {
    let list = card-poison; // String
    let word = test; // String

    let mut context = WordlistApi::Context::default();
    let result = client.putWord(list, word, &context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        WordlistApi apiInstance = new WordlistApi();
        String list = card-poison; // String | Name of word list to use.
        WordlistBody wordlistBody = ; // WordlistBody | 

        try {
            putRoom_200_response result = apiInstance.putWordList(list, wordlistBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WordlistApi#putWordList");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String list = new String(); // String | Name of word list to use.
final WordlistBody wordlistBody = new WordlistBody(); // WordlistBody | 

try {
    final result = await api_instance.putWordList(list, wordlistBody);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->putWordList: $e\n');
}

import org.openapitools.client.api.WordlistApi;

public class WordlistApiExample {
    public static void main(String[] args) {
        WordlistApi apiInstance = new WordlistApi();
        String list = card-poison; // String | Name of word list to use.
        WordlistBody wordlistBody = ; // WordlistBody | 

        try {
            putRoom_200_response result = apiInstance.putWordList(list, wordlistBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WordlistApi#putWordList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
WordlistApi *apiInstance = [[WordlistApi alloc] init];
String *list = card-poison; // Name of word list to use. (default to null)
WordlistBody *wordlistBody = ; //  (optional)

// Add wordlist
[apiInstance putWordListWith:list
    wordlistBody:wordlistBody
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.WordlistApi()
var list = card-poison; // {String} Name of word list to use.
var opts = {
  'wordlistBody':  // {WordlistBody} 
};

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

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

namespace Example
{
    public class putWordListExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new WordlistApi();
            var list = card-poison;  // String | Name of word list to use. (default to null)
            var wordlistBody = new WordlistBody(); // WordlistBody |  (optional) 

            try {
                // Add wordlist
                putRoom_200_response result = apiInstance.putWordList(list, wordlistBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling WordlistApi.putWordList: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\WordlistApi();
$list = card-poison; // String | Name of word list to use.
$wordlistBody = ; // WordlistBody | 

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::WordlistApi->new();
my $list = card-poison; # String | Name of word list to use.
my $wordlistBody = WWW::OPenAPIClient::Object::WordlistBody->new(); # WordlistBody | 

eval {
    my $result = $api_instance->putWordList(list => $list, wordlistBody => $wordlistBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WordlistApi->putWordList: $@\n";
}

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.WordlistApi()
list = card-poison # String | Name of word list to use. (default to null)
wordlistBody =  # WordlistBody |  (optional)

try:
    # Add wordlist
    api_response = api_instance.put_word_list(list, wordlistBody=wordlistBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WordlistApi->putWordList: %s\n" % e)

extern crate WordlistApi;

pub fn main() {
    let list = card-poison; // String
    let wordlistBody = ; // WordlistBody

    let mut context = WordlistApi::Context::default();
    let result = client.putWordList(list, wordlistBody, &context).wait();

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

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

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

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

        // Configure Bearer access token for authorization: JWTAuth
        HttpBearerAuth JWTAuth = (HttpBearerAuth) defaultClient.getAuthentication("JWTAuth");
        JWTAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        WordlistApi apiInstance = new WordlistApi();
        String list = card-poison; // String | Name of word list to use.
        WordsBody wordsBody = ; // WordsBody | 

        try {
            putRoom_200_response result = apiInstance.putWords(list, wordsBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WordlistApi#putWords");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String list = new String(); // String | Name of word list to use.
final WordsBody wordsBody = new WordsBody(); // WordsBody | 

try {
    final result = await api_instance.putWords(list, wordsBody);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->putWords: $e\n');
}

import org.openapitools.client.api.WordlistApi;

public class WordlistApiExample {
    public static void main(String[] args) {
        WordlistApi apiInstance = new WordlistApi();
        String list = card-poison; // String | Name of word list to use.
        WordsBody wordsBody = ; // WordsBody | 

        try {
            putRoom_200_response result = apiInstance.putWords(list, wordsBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling WordlistApi#putWords");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: JWTAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
WordlistApi *apiInstance = [[WordlistApi alloc] init];
String *list = card-poison; // Name of word list to use. (default to null)
WordsBody *wordsBody = ; //  (optional)

// Add words to wordlist
[apiInstance putWordsWith:list
    wordsBody:wordsBody
              completionHandler: ^(putRoom_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var WordAssassinApi = require('word_assassin_api');
var defaultClient = WordAssassinApi.ApiClient.instance;

// Configure Bearer access token for authorization: JWTAuth
var JWTAuth = defaultClient.authentications['JWTAuth'];
JWTAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new WordAssassinApi.WordlistApi()
var list = card-poison; // {String} Name of word list to use.
var opts = {
  'wordsBody':  // {WordsBody} 
};

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

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

namespace Example
{
    public class putWordsExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: JWTAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new WordlistApi();
            var list = card-poison;  // String | Name of word list to use. (default to null)
            var wordsBody = new WordsBody(); // WordsBody |  (optional) 

            try {
                // Add words to wordlist
                putRoom_200_response result = apiInstance.putWords(list, wordsBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling WordlistApi.putWords: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer access token for authorization: JWTAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\WordlistApi();
$list = card-poison; // String | Name of word list to use.
$wordsBody = ; // WordsBody | 

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

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

# Configure Bearer access token for authorization: JWTAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::WordlistApi->new();
my $list = card-poison; # String | Name of word list to use.
my $wordsBody = WWW::OPenAPIClient::Object::WordsBody->new(); # WordsBody | 

eval {
    my $result = $api_instance->putWords(list => $list, wordsBody => $wordsBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling WordlistApi->putWords: $@\n";
}

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

# Configure Bearer access token for authorization: JWTAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.WordlistApi()
list = card-poison # String | Name of word list to use. (default to null)
wordsBody =  # WordsBody |  (optional)

try:
    # Add words to wordlist
    api_response = api_instance.put_words(list, wordsBody=wordsBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling WordlistApi->putWords: %s\n" % e)

extern crate WordlistApi;

pub fn main() {
    let list = card-poison; // String
    let wordsBody = ; // WordsBody

    let mut context = WordlistApi::Context::default();
    let result = client.putWords(list, wordsBody, &context).wait();

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