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

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

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

        // Create an instance of the API class
        AnnotationApi apiInstance = new AnnotationApi();
        String path = path_example; // String | Path of file, relative to source root.

        try {
            array[AnnotationEntry] result = apiInstance.getAnnotation(path);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AnnotationApi#getAnnotation");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String path = new String(); // String | Path of file, relative to source root.

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

import org.openapitools.client.api.AnnotationApi;

public class AnnotationApiExample {
    public static void main(String[] args) {
        AnnotationApi apiInstance = new AnnotationApi();
        String path = path_example; // String | Path of file, relative to source root.

        try {
            array[AnnotationEntry] result = apiInstance.getAnnotation(path);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AnnotationApi#getAnnotation");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AnnotationApi *apiInstance = [[AnnotationApi alloc] init];
String *path = path_example; // Path of file, relative to source root. (default to null)

// Get annotation for a file
[apiInstance getAnnotationWith:path
              completionHandler: ^(array[AnnotationEntry] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');

// Create an instance of the API class
var api = new OpenGrokResTfulApi.AnnotationApi()
var path = path_example; // {String} Path of file, relative to source root.

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

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

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

            // Create an instance of the API class
            var apiInstance = new AnnotationApi();
            var path = path_example;  // String | Path of file, relative to source root. (default to null)

            try {
                // Get annotation for a file
                array[AnnotationEntry] result = apiInstance.getAnnotation(path);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AnnotationApi.getAnnotation: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AnnotationApi();
$path = path_example; // String | Path of file, relative to source root.

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AnnotationApi->new();
my $path = path_example; # String | Path of file, relative to source root.

eval {
    my $result = $api_instance->getAnnotation(path => $path);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AnnotationApi->getAnnotation: $@\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.AnnotationApi()
path = path_example # String | Path of file, relative to source root. (default to null)

try:
    # Get annotation for a file
    api_response = api_instance.get_annotation(path)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AnnotationApi->getAnnotation: %s\n" % e)

extern crate AnnotationApi;

pub fn main() {
    let path = path_example; // String

    let mut context = AnnotationApi::Context::default();
    let result = client.getAnnotation(path, &context).wait();

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

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

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

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

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

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

        try {
            'String' result = apiInstance.getConfiguration();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConfigurationApi#getConfiguration");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.ConfigurationApi;

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

        try {
            'String' result = apiInstance.getConfiguration();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConfigurationApi#getConfiguration");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

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

// Return XML representation of configuration
[apiInstance getConfigurationWithCompletionHandler: 
              ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');
var defaultClient = OpenGrokResTfulApi.ApiClient.instance;

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

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

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

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

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

            try {
                // Return XML representation of configuration
                'String' result = apiInstance.getConfiguration();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConfigurationApi.getConfiguration: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

# Configure Bearer (token) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Return XML representation of configuration
    api_response = api_instance.get_configuration()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConfigurationApi->getConfiguration: %s\n" % e)

extern crate ConfigurationApi;

pub fn main() {

    let mut context = ConfigurationApi::Context::default();
    let result = client.getConfiguration(&context).wait();

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

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

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

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

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

        // Create an instance of the API class
        ConfigurationApi apiInstance = new ConfigurationApi();
        String field = field_example; // String | Configuration field name.

        try {
            oas_any_type_not_mapped result = apiInstance.getConfigurationField(field);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConfigurationApi#getConfigurationField");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String field = new String(); // String | Configuration field name.

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

import org.openapitools.client.api.ConfigurationApi;

public class ConfigurationApiExample {
    public static void main(String[] args) {
        ConfigurationApi apiInstance = new ConfigurationApi();
        String field = field_example; // String | Configuration field name.

        try {
            oas_any_type_not_mapped result = apiInstance.getConfigurationField(field);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConfigurationApi#getConfigurationField");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
ConfigurationApi *apiInstance = [[ConfigurationApi alloc] init];
String *field = field_example; // Configuration field name. (default to null)

// Return a specific configuration field
[apiInstance getConfigurationFieldWith:field
              completionHandler: ^(oas_any_type_not_mapped output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');
var defaultClient = OpenGrokResTfulApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new OpenGrokResTfulApi.ConfigurationApi()
var field = field_example; // {String} Configuration field name.

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

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

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

            // Create an instance of the API class
            var apiInstance = new ConfigurationApi();
            var field = field_example;  // String | Configuration field name. (default to null)

            try {
                // Return a specific configuration field
                oas_any_type_not_mapped result = apiInstance.getConfigurationField(field);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConfigurationApi.getConfigurationField: " + e.Message );
            }
        }
    }
}

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ConfigurationApi();
$field = field_example; // String | Configuration field name.

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

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ConfigurationApi->new();
my $field = field_example; # String | Configuration field name.

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

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

# Configure Bearer (token) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ConfigurationApi()
field = field_example # String | Configuration field name. (default to null)

try:
    # Return a specific configuration field
    api_response = api_instance.get_configuration_field(field)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConfigurationApi->getConfigurationField: %s\n" % e)

extern crate ConfigurationApi;

pub fn main() {
    let field = field_example; // String

    let mut context = ConfigurationApi::Context::default();
    let result = client.getConfigurationField(field, &context).wait();

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

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

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

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

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

        // Create an instance of the API class
        ConfigurationApi apiInstance = new ConfigurationApi();
        String body = body_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String body = new String(); // String | 

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

import org.openapitools.client.api.ConfigurationApi;

public class ConfigurationApiExample {
    public static void main(String[] args) {
        ConfigurationApi apiInstance = new ConfigurationApi();
        String body = body_example; // String | 

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

Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
ConfigurationApi *apiInstance = [[ConfigurationApi alloc] init];
String *body = body_example; //  (optional)

// Reload authorization framework
[apiInstance reloadAuthorizationFrameworkWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');
var defaultClient = OpenGrokResTfulApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new OpenGrokResTfulApi.ConfigurationApi()
var opts = {
  'body': body_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ConfigurationApi();
            var body = body_example;  // String |  (optional) 

            try {
                // Reload authorization framework
                apiInstance.reloadAuthorizationFramework(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConfigurationApi.reloadAuthorizationFramework: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

# Configure Bearer (token) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ConfigurationApi()
body = body_example # String |  (optional)

try:
    # Reload authorization framework
    api_instance.reload_authorization_framework(body=body)
except ApiException as e:
    print("Exception when calling ConfigurationApi->reloadAuthorizationFramework: %s\n" % e)

extern crate ConfigurationApi;

pub fn main() {
    let body = body_example; // String

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

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

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

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

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

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

        // Create an instance of the API class
        ConfigurationApi apiInstance = new ConfigurationApi();
        String body = 

 

; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String body = new String(); // String | 

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

import org.openapitools.client.api.ConfigurationApi;

public class ConfigurationApiExample {
    public static void main(String[] args) {
        ConfigurationApi apiInstance = new ConfigurationApi();
        String body = 

 

; // String | 

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

Configuration *apiConfig = [Configuration sharedConfig];

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

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

 

; // 

// Set configuration from XML representation
[apiInstance setConfigurationWith:body
              completionHandler: ^(oas_any_type_not_mapped output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');
var defaultClient = OpenGrokResTfulApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new OpenGrokResTfulApi.ConfigurationApi()
var body = 

 

; // {String} 

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

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

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

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

 

;  // String | 

            try {
                // Set configuration from XML representation
                oas_any_type_not_mapped result = apiInstance.setConfiguration(body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConfigurationApi.setConfiguration: " + e.Message );
            }
        }
    }
}

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

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

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

 

; // String | 

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

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

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

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

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

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

# Configure Bearer (token) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

 

 # String | 

try:
    # Set configuration from XML representation
    api_response = api_instance.set_configuration(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConfigurationApi->setConfiguration: %s\n" % e)

extern crate ConfigurationApi;

pub fn main() {
    let body = 

 

; // String

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

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

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

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

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

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

        // Create an instance of the API class
        ConfigurationApi apiInstance = new ConfigurationApi();
        String field = field_example; // String | Configuration field name.
        String body = string value of the field to set; // String | 
        Boolean reindex = true; // Boolean | Specifies if the underlying data were also reindexed. Refreshes some searchers and additional data structures.

        try {
            apiInstance.setConfigurationField(field, body, reindex);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConfigurationApi#setConfigurationField");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String field = new String(); // String | Configuration field name.
final String body = new String(); // String | 
final Boolean reindex = new Boolean(); // Boolean | Specifies if the underlying data were also reindexed. Refreshes some searchers and additional data structures.

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

import org.openapitools.client.api.ConfigurationApi;

public class ConfigurationApiExample {
    public static void main(String[] args) {
        ConfigurationApi apiInstance = new ConfigurationApi();
        String field = field_example; // String | Configuration field name.
        String body = string value of the field to set; // String | 
        Boolean reindex = true; // Boolean | Specifies if the underlying data were also reindexed. Refreshes some searchers and additional data structures.

        try {
            apiInstance.setConfigurationField(field, body, reindex);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConfigurationApi#setConfigurationField");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
ConfigurationApi *apiInstance = [[ConfigurationApi alloc] init];
String *field = field_example; // Configuration field name. (default to null)
String *body = string value of the field to set; // 
Boolean *reindex = true; // Specifies if the underlying data were also reindexed. Refreshes some searchers and additional data structures. (optional) (default to null)

// Set a specific configuration field
[apiInstance setConfigurationFieldWith:field
    body:body
    reindex:reindex
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');
var defaultClient = OpenGrokResTfulApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new OpenGrokResTfulApi.ConfigurationApi()
var field = field_example; // {String} Configuration field name.
var body = string value of the field to set; // {String} 
var opts = {
  'reindex': true // {Boolean} Specifies if the underlying data were also reindexed. Refreshes some searchers and additional data structures.
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ConfigurationApi();
            var field = field_example;  // String | Configuration field name. (default to null)
            var body = string value of the field to set;  // String | 
            var reindex = true;  // Boolean | Specifies if the underlying data were also reindexed. Refreshes some searchers and additional data structures. (optional)  (default to null)

            try {
                // Set a specific configuration field
                apiInstance.setConfigurationField(field, body, reindex);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConfigurationApi.setConfigurationField: " + e.Message );
            }
        }
    }
}

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ConfigurationApi();
$field = field_example; // String | Configuration field name.
$body = string value of the field to set; // String | 
$reindex = true; // Boolean | Specifies if the underlying data were also reindexed. Refreshes some searchers and additional data structures.

try {
    $api_instance->setConfigurationField($field, $body, $reindex);
} catch (Exception $e) {
    echo 'Exception when calling ConfigurationApi->setConfigurationField: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ConfigurationApi->new();
my $field = field_example; # String | Configuration field name.
my $body = WWW::OPenAPIClient::Object::String->new(); # String | 
my $reindex = true; # Boolean | Specifies if the underlying data were also reindexed. Refreshes some searchers and additional data structures.

eval {
    $api_instance->setConfigurationField(field => $field, body => $body, reindex => $reindex);
};
if ($@) {
    warn "Exception when calling ConfigurationApi->setConfigurationField: $@\n";
}

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

# Configure Bearer (token) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ConfigurationApi()
field = field_example # String | Configuration field name. (default to null)
body = string value of the field to set # String | 
reindex = true # Boolean | Specifies if the underlying data were also reindexed. Refreshes some searchers and additional data structures. (optional) (default to null)

try:
    # Set a specific configuration field
    api_instance.set_configuration_field(field, body, reindex=reindex)
except ApiException as e:
    print("Exception when calling ConfigurationApi->setConfigurationField: %s\n" % e)

extern crate ConfigurationApi;

pub fn main() {
    let field = field_example; // String
    let body = string value of the field to set; // String
    let reindex = true; // Boolean

    let mut context = ConfigurationApi::Context::default();
    let result = client.setConfigurationField(field, body, reindex, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DirectoryListingApi apiInstance = new DirectoryListingApi();
        String path = path_example; // String | Path of file/directory to get listing for, relative to source root, starting with `/`.

        try {
            array[DirectoryEntry] result = apiInstance.getDirectoryListing(path);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DirectoryListingApi#getDirectoryListing");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String path = new String(); // String | Path of file/directory to get listing for, relative to source root, starting with `/`.

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

import org.openapitools.client.api.DirectoryListingApi;

public class DirectoryListingApiExample {
    public static void main(String[] args) {
        DirectoryListingApi apiInstance = new DirectoryListingApi();
        String path = path_example; // String | Path of file/directory to get listing for, relative to source root, starting with `/`.

        try {
            array[DirectoryEntry] result = apiInstance.getDirectoryListing(path);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DirectoryListingApi#getDirectoryListing");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DirectoryListingApi *apiInstance = [[DirectoryListingApi alloc] init];
String *path = path_example; // Path of file/directory to get listing for, relative to source root, starting with `/`. (default to null)

// Get directory entries
[apiInstance getDirectoryListingWith:path
              completionHandler: ^(array[DirectoryEntry] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');

// Create an instance of the API class
var api = new OpenGrokResTfulApi.DirectoryListingApi()
var path = path_example; // {String} Path of file/directory to get listing for, relative to source root, starting with `/`.

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

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

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

            // Create an instance of the API class
            var apiInstance = new DirectoryListingApi();
            var path = path_example;  // String | Path of file/directory to get listing for, relative to source root, starting with `/`. (default to null)

            try {
                // Get directory entries
                array[DirectoryEntry] result = apiInstance.getDirectoryListing(path);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DirectoryListingApi.getDirectoryListing: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DirectoryListingApi();
$path = path_example; // String | Path of file/directory to get listing for, relative to source root, starting with `/`.

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DirectoryListingApi->new();
my $path = path_example; # String | Path of file/directory to get listing for, relative to source root, starting with `/`.

eval {
    my $result = $api_instance->getDirectoryListing(path => $path);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DirectoryListingApi->getDirectoryListing: $@\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.DirectoryListingApi()
path = path_example # String | Path of file/directory to get listing for, relative to source root, starting with `/`. (default to null)

try:
    # Get directory entries
    api_response = api_instance.get_directory_listing(path)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DirectoryListingApi->getDirectoryListing: %s\n" % e)

extern crate DirectoryListingApi;

pub fn main() {
    let path = path_example; // String

    let mut context = DirectoryListingApi::Context::default();
    let result = client.getDirectoryListing(path, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FileApi apiInstance = new FileApi();
        String path = path_example; // String | Path of file, relative to source root.

        try {
            'String' result = apiInstance.getFileContent(path);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FileApi#getFileContent");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String path = new String(); // String | Path of file, relative to source root.

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

import org.openapitools.client.api.FileApi;

public class FileApiExample {
    public static void main(String[] args) {
        FileApi apiInstance = new FileApi();
        String path = path_example; // String | Path of file, relative to source root.

        try {
            'String' result = apiInstance.getFileContent(path);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FileApi#getFileContent");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
FileApi *apiInstance = [[FileApi alloc] init];
String *path = path_example; // Path of file, relative to source root. (default to null)

// Get file content
[apiInstance getFileContentWith:path
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');

// Create an instance of the API class
var api = new OpenGrokResTfulApi.FileApi()
var path = path_example; // {String} Path of file, relative to source root.

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

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

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

            // Create an instance of the API class
            var apiInstance = new FileApi();
            var path = path_example;  // String | Path of file, relative to source root. (default to null)

            try {
                // Get file content
                'String' result = apiInstance.getFileContent(path);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FileApi.getFileContent: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FileApi();
$path = path_example; // String | Path of file, relative to source root.

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FileApi->new();
my $path = path_example; # String | Path of file, relative to source root.

eval {
    my $result = $api_instance->getFileContent(path => $path);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FileApi->getFileContent: $@\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.FileApi()
path = path_example # String | Path of file, relative to source root. (default to null)

try:
    # Get file content
    api_response = api_instance.get_file_content(path)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FileApi->getFileContent: %s\n" % e)

extern crate FileApi;

pub fn main() {
    let path = path_example; // String

    let mut context = FileApi::Context::default();
    let result = client.getFileContent(path, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FileApi apiInstance = new FileApi();
        String path = path_example; // String | Path of file, relative to source root.

        try {
            array[FileDefinition] result = apiInstance.getFileDefinitions(path);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FileApi#getFileDefinitions");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String path = new String(); // String | Path of file, relative to source root.

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

import org.openapitools.client.api.FileApi;

public class FileApiExample {
    public static void main(String[] args) {
        FileApi apiInstance = new FileApi();
        String path = path_example; // String | Path of file, relative to source root.

        try {
            array[FileDefinition] result = apiInstance.getFileDefinitions(path);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FileApi#getFileDefinitions");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
FileApi *apiInstance = [[FileApi alloc] init];
String *path = path_example; // Path of file, relative to source root. (default to null)

// Get file definitions
[apiInstance getFileDefinitionsWith:path
              completionHandler: ^(array[FileDefinition] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');

// Create an instance of the API class
var api = new OpenGrokResTfulApi.FileApi()
var path = path_example; // {String} Path of file, relative to source root.

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

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

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

            // Create an instance of the API class
            var apiInstance = new FileApi();
            var path = path_example;  // String | Path of file, relative to source root. (default to null)

            try {
                // Get file definitions
                array[FileDefinition] result = apiInstance.getFileDefinitions(path);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FileApi.getFileDefinitions: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FileApi();
$path = path_example; // String | Path of file, relative to source root.

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FileApi->new();
my $path = path_example; # String | Path of file, relative to source root.

eval {
    my $result = $api_instance->getFileDefinitions(path => $path);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FileApi->getFileDefinitions: $@\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.FileApi()
path = path_example # String | Path of file, relative to source root. (default to null)

try:
    # Get file definitions
    api_response = api_instance.get_file_definitions(path)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FileApi->getFileDefinitions: %s\n" % e)

extern crate FileApi;

pub fn main() {
    let path = path_example; // String

    let mut context = FileApi::Context::default();
    let result = client.getFileDefinitions(path, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FileApi apiInstance = new FileApi();
        String path = path_example; // String | Path of file, relative to source root.

        try {
            'String' result = apiInstance.getFileGenre(path);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FileApi#getFileGenre");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String path = new String(); // String | Path of file, relative to source root.

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

import org.openapitools.client.api.FileApi;

public class FileApiExample {
    public static void main(String[] args) {
        FileApi apiInstance = new FileApi();
        String path = path_example; // String | Path of file, relative to source root.

        try {
            'String' result = apiInstance.getFileGenre(path);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FileApi#getFileGenre");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
FileApi *apiInstance = [[FileApi alloc] init];
String *path = path_example; // Path of file, relative to source root. (default to null)

// Get file genre
[apiInstance getFileGenreWith:path
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');

// Create an instance of the API class
var api = new OpenGrokResTfulApi.FileApi()
var path = path_example; // {String} Path of file, relative to source root.

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

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

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

            // Create an instance of the API class
            var apiInstance = new FileApi();
            var path = path_example;  // String | Path of file, relative to source root. (default to null)

            try {
                // Get file genre
                'String' result = apiInstance.getFileGenre(path);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FileApi.getFileGenre: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FileApi();
$path = path_example; // String | Path of file, relative to source root.

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FileApi->new();
my $path = path_example; # String | Path of file, relative to source root.

eval {
    my $result = $api_instance->getFileGenre(path => $path);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FileApi->getFileGenre: $@\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.FileApi()
path = path_example # String | Path of file, relative to source root. (default to null)

try:
    # Get file genre
    api_response = api_instance.get_file_genre(path)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FileApi->getFileGenre: %s\n" % e)

extern crate FileApi;

pub fn main() {
    let path = path_example; // String

    let mut context = FileApi::Context::default();
    let result = client.getFileGenre(path, &context).wait();

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

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

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

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

        // Create an instance of the API class
        GroupsApi apiInstance = new GroupsApi();
        String group = group_example; // String | Group name.

        try {
            'String' result = apiInstance.getGroupPattern(group);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupsApi#getGroupPattern");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String group = new String(); // String | Group name.

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

import org.openapitools.client.api.GroupsApi;

public class GroupsApiExample {
    public static void main(String[] args) {
        GroupsApi apiInstance = new GroupsApi();
        String group = group_example; // String | Group name.

        try {
            'String' result = apiInstance.getGroupPattern(group);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupsApi#getGroupPattern");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
GroupsApi *apiInstance = [[GroupsApi alloc] init];
String *group = group_example; // Group name. (default to null)

// Return pattern for given group
[apiInstance getGroupPatternWith:group
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');

// Create an instance of the API class
var api = new OpenGrokResTfulApi.GroupsApi()
var group = group_example; // {String} Group name.

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

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

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

            // Create an instance of the API class
            var apiInstance = new GroupsApi();
            var group = group_example;  // String | Group name. (default to null)

            try {
                // Return pattern for given group
                'String' result = apiInstance.getGroupPattern(group);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GroupsApi.getGroupPattern: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GroupsApi();
$group = group_example; // String | Group name.

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GroupsApi->new();
my $group = group_example; # String | Group name.

eval {
    my $result = $api_instance->getGroupPattern(group => $group);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GroupsApi->getGroupPattern: $@\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.GroupsApi()
group = group_example # String | Group name. (default to null)

try:
    # Return pattern for given group
    api_response = api_instance.get_group_pattern(group)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GroupsApi->getGroupPattern: %s\n" % e)

extern crate GroupsApi;

pub fn main() {
    let group = group_example; // String

    let mut context = GroupsApi::Context::default();
    let result = client.getGroupPattern(group, &context).wait();

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

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

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

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

        // Create an instance of the API class
        GroupsApi apiInstance = new GroupsApi();
        String group = group_example; // String | Group name.

        try {
            array['String'] result = apiInstance.getGroupProjects(group);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupsApi#getGroupProjects");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String group = new String(); // String | Group name.

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

import org.openapitools.client.api.GroupsApi;

public class GroupsApiExample {
    public static void main(String[] args) {
        GroupsApi apiInstance = new GroupsApi();
        String group = group_example; // String | Group name.

        try {
            array['String'] result = apiInstance.getGroupProjects(group);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupsApi#getGroupProjects");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
GroupsApi *apiInstance = [[GroupsApi alloc] init];
String *group = group_example; // Group name. (default to null)

// Return list of all projects for a group
[apiInstance getGroupProjectsWith:group
              completionHandler: ^(array['String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');

// Create an instance of the API class
var api = new OpenGrokResTfulApi.GroupsApi()
var group = group_example; // {String} Group name.

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

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

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

            // Create an instance of the API class
            var apiInstance = new GroupsApi();
            var group = group_example;  // String | Group name. (default to null)

            try {
                // Return list of all projects for a group
                array['String'] result = apiInstance.getGroupProjects(group);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GroupsApi.getGroupProjects: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GroupsApi();
$group = group_example; // String | Group name.

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GroupsApi->new();
my $group = group_example; # String | Group name.

eval {
    my $result = $api_instance->getGroupProjects(group => $group);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GroupsApi->getGroupProjects: $@\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.GroupsApi()
group = group_example # String | Group name. (default to null)

try:
    # Return list of all projects for a group
    api_response = api_instance.get_group_projects(group)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GroupsApi->getGroupProjects: %s\n" % e)

extern crate GroupsApi;

pub fn main() {
    let group = group_example; // String

    let mut context = GroupsApi::Context::default();
    let result = client.getGroupProjects(group, &context).wait();

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

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

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

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

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

        try {
            array['String'] result = apiInstance.getGroups();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupsApi#getGroups");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.GroupsApi;

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

        try {
            array['String'] result = apiInstance.getGroups();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupsApi#getGroups");
            e.printStackTrace();
        }
    }
}

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

// Return a list of all groups
[apiInstance getGroupsWithCompletionHandler: 
              ^(array['String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');

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

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

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

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

            try {
                // Return a list of all groups
                array['String'] result = apiInstance.getGroups();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GroupsApi.getGroups: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->getGroups();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GroupsApi->getGroups: $@\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.GroupsApi()

try:
    # Return a list of all groups
    api_response = api_instance.get_groups()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GroupsApi->getGroups: %s\n" % e)

extern crate GroupsApi;

pub fn main() {

    let mut context = GroupsApi::Context::default();
    let result = client.getGroups(&context).wait();

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

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

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

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

        // Create an instance of the API class
        GroupsApi apiInstance = new GroupsApi();
        String group = group_example; // String | Group name.
        String body = name of the project; // String | 

        try {
            apiInstance.matchGroupPattern(group, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupsApi#matchGroupPattern");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String group = new String(); // String | Group name.
final String body = new String(); // String | 

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

import org.openapitools.client.api.GroupsApi;

public class GroupsApiExample {
    public static void main(String[] args) {
        GroupsApi apiInstance = new GroupsApi();
        String group = group_example; // String | Group name.
        String body = name of the project; // String | 

        try {
            apiInstance.matchGroupPattern(group, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupsApi#matchGroupPattern");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
GroupsApi *apiInstance = [[GroupsApi alloc] init];
String *group = group_example; // Group name. (default to null)
String *body = name of the project; // 

// Check if project name matches group pattern
[apiInstance matchGroupPatternWith:group
    body:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');

// Create an instance of the API class
var api = new OpenGrokResTfulApi.GroupsApi()
var group = group_example; // {String} Group name.
var body = name of the project; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new GroupsApi();
            var group = group_example;  // String | Group name. (default to null)
            var body = name of the project;  // String | 

            try {
                // Check if project name matches group pattern
                apiInstance.matchGroupPattern(group, body);
            } catch (Exception e) {
                Debug.Print("Exception when calling GroupsApi.matchGroupPattern: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GroupsApi();
$group = group_example; // String | Group name.
$body = name of the project; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GroupsApi->new();
my $group = group_example; # String | Group name.
my $body = WWW::OPenAPIClient::Object::String->new(); # String | 

eval {
    $api_instance->matchGroupPattern(group => $group, body => $body);
};
if ($@) {
    warn "Exception when calling GroupsApi->matchGroupPattern: $@\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.GroupsApi()
group = group_example # String | Group name. (default to null)
body = name of the project # String | 

try:
    # Check if project name matches group pattern
    api_instance.match_group_pattern(group, body)
except ApiException as e:
    print("Exception when calling GroupsApi->matchGroupPattern: %s\n" % e)

extern crate GroupsApi;

pub fn main() {
    let group = group_example; // String
    let body = name of the project; // String

    let mut context = GroupsApi::Context::default();
    let result = client.matchGroupPattern(group, body, &context).wait();

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

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

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

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

        // Create an instance of the API class
        HistoryApi apiInstance = new HistoryApi();
        String path = path_example; // String | Path of file/directory to get history for, relative to source root.
        Boolean withFiles = true; // Boolean | Whether to include list of files.
        Integer start = 56; // Integer | Start index.
        Integer max = 56; // Integer | Number of entries to get.

        try {
            HistoryResponse result = apiInstance.getHistory(path, withFiles, start, max);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HistoryApi#getHistory");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String path = new String(); // String | Path of file/directory to get history for, relative to source root.
final Boolean withFiles = new Boolean(); // Boolean | Whether to include list of files.
final Integer start = new Integer(); // Integer | Start index.
final Integer max = new Integer(); // Integer | Number of entries to get.

try {
    final result = await api_instance.getHistory(path, withFiles, start, max);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getHistory: $e\n');
}

import org.openapitools.client.api.HistoryApi;

public class HistoryApiExample {
    public static void main(String[] args) {
        HistoryApi apiInstance = new HistoryApi();
        String path = path_example; // String | Path of file/directory to get history for, relative to source root.
        Boolean withFiles = true; // Boolean | Whether to include list of files.
        Integer start = 56; // Integer | Start index.
        Integer max = 56; // Integer | Number of entries to get.

        try {
            HistoryResponse result = apiInstance.getHistory(path, withFiles, start, max);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HistoryApi#getHistory");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
HistoryApi *apiInstance = [[HistoryApi alloc] init];
String *path = path_example; // Path of file/directory to get history for, relative to source root. (default to null)
Boolean *withFiles = true; // Whether to include list of files. (optional) (default to null)
Integer *start = 56; // Start index. (optional) (default to null)
Integer *max = 56; // Number of entries to get. (optional) (default to 1000)

// Get history entries
[apiInstance getHistoryWith:path
    withFiles:withFiles
    start:start
    max:max
              completionHandler: ^(HistoryResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');

// Create an instance of the API class
var api = new OpenGrokResTfulApi.HistoryApi()
var path = path_example; // {String} Path of file/directory to get history for, relative to source root.
var opts = {
  'withFiles': true, // {Boolean} Whether to include list of files.
  'start': 56, // {Integer} Start index.
  'max': 56 // {Integer} Number of entries to get.
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new HistoryApi();
            var path = path_example;  // String | Path of file/directory to get history for, relative to source root. (default to null)
            var withFiles = true;  // Boolean | Whether to include list of files. (optional)  (default to null)
            var start = 56;  // Integer | Start index. (optional)  (default to null)
            var max = 56;  // Integer | Number of entries to get. (optional)  (default to 1000)

            try {
                // Get history entries
                HistoryResponse result = apiInstance.getHistory(path, withFiles, start, max);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling HistoryApi.getHistory: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\HistoryApi();
$path = path_example; // String | Path of file/directory to get history for, relative to source root.
$withFiles = true; // Boolean | Whether to include list of files.
$start = 56; // Integer | Start index.
$max = 56; // Integer | Number of entries to get.

try {
    $result = $api_instance->getHistory($path, $withFiles, $start, $max);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling HistoryApi->getHistory: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::HistoryApi->new();
my $path = path_example; # String | Path of file/directory to get history for, relative to source root.
my $withFiles = true; # Boolean | Whether to include list of files.
my $start = 56; # Integer | Start index.
my $max = 56; # Integer | Number of entries to get.

eval {
    my $result = $api_instance->getHistory(path => $path, withFiles => $withFiles, start => $start, max => $max);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HistoryApi->getHistory: $@\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.HistoryApi()
path = path_example # String | Path of file/directory to get history for, relative to source root. (default to null)
withFiles = true # Boolean | Whether to include list of files. (optional) (default to null)
start = 56 # Integer | Start index. (optional) (default to null)
max = 56 # Integer | Number of entries to get. (optional) (default to 1000)

try:
    # Get history entries
    api_response = api_instance.get_history(path, withFiles=withFiles, start=start, max=max)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HistoryApi->getHistory: %s\n" % e)

extern crate HistoryApi;

pub fn main() {
    let path = path_example; // String
    let withFiles = true; // Boolean
    let start = 56; // Integer
    let max = 56; // Integer

    let mut context = HistoryApi::Context::default();
    let result = client.getHistory(path, withFiles, start, max, &context).wait();

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

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

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

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

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

        // Create an instance of the API class
        MessagesApi apiInstance = new MessagesApi();
        MessageCreateRequest messageCreateRequest = {"tags":["main"],"messageLevel":"info","text":"test message","duration":"PT10M"}; // MessageCreateRequest | 

        try {
            apiInstance.addMessage(messageCreateRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagesApi#addMessage");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final MessageCreateRequest messageCreateRequest = new MessageCreateRequest(); // MessageCreateRequest | 

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

import org.openapitools.client.api.MessagesApi;

public class MessagesApiExample {
    public static void main(String[] args) {
        MessagesApi apiInstance = new MessagesApi();
        MessageCreateRequest messageCreateRequest = {"tags":["main"],"messageLevel":"info","text":"test message","duration":"PT10M"}; // MessageCreateRequest | 

        try {
            apiInstance.addMessage(messageCreateRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagesApi#addMessage");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
MessagesApi *apiInstance = [[MessagesApi alloc] init];
MessageCreateRequest *messageCreateRequest = {"tags":["main"],"messageLevel":"info","text":"test message","duration":"PT10M"}; // 

// Add message to the system
[apiInstance addMessageWith:messageCreateRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');
var defaultClient = OpenGrokResTfulApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new OpenGrokResTfulApi.MessagesApi()
var messageCreateRequest = {"tags":["main"],"messageLevel":"info","text":"test message","duration":"PT10M"}; // {MessageCreateRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new MessagesApi();
            var messageCreateRequest = new MessageCreateRequest(); // MessageCreateRequest | 

            try {
                // Add message to the system
                apiInstance.addMessage(messageCreateRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling MessagesApi.addMessage: " + e.Message );
            }
        }
    }
}

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MessagesApi();
$messageCreateRequest = {"tags":["main"],"messageLevel":"info","text":"test message","duration":"PT10M"}; // MessageCreateRequest | 

try {
    $api_instance->addMessage($messageCreateRequest);
} catch (Exception $e) {
    echo 'Exception when calling MessagesApi->addMessage: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

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

eval {
    $api_instance->addMessage(messageCreateRequest => $messageCreateRequest);
};
if ($@) {
    warn "Exception when calling MessagesApi->addMessage: $@\n";
}

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

# Configure Bearer (token) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.MessagesApi()
messageCreateRequest = {"tags":["main"],"messageLevel":"info","text":"test message","duration":"PT10M"} # MessageCreateRequest | 

try:
    # Add message to the system
    api_instance.add_message(messageCreateRequest)
except ApiException as e:
    print("Exception when calling MessagesApi->addMessage: %s\n" % e)

extern crate MessagesApi;

pub fn main() {
    let messageCreateRequest = {"tags":["main"],"messageLevel":"info","text":"test message","duration":"PT10M"}; // MessageCreateRequest

    let mut context = MessagesApi::Context::default();
    let result = client.addMessage(messageCreateRequest, &context).wait();

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

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

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

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

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

        // Create an instance of the API class
        MessagesApi apiInstance = new MessagesApi();
        String tag = tag_example; // String | Message tag.
        String body = string value of the message text - only messages with the text (and specified tag) will be deleted; // String | 

        try {
            apiInstance.deleteMessages(tag, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagesApi#deleteMessages");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String tag = new String(); // String | Message tag.
final String body = new String(); // String | 

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

import org.openapitools.client.api.MessagesApi;

public class MessagesApiExample {
    public static void main(String[] args) {
        MessagesApi apiInstance = new MessagesApi();
        String tag = tag_example; // String | Message tag.
        String body = string value of the message text - only messages with the text (and specified tag) will be deleted; // String | 

        try {
            apiInstance.deleteMessages(tag, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagesApi#deleteMessages");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
MessagesApi *apiInstance = [[MessagesApi alloc] init];
String *tag = tag_example; // Message tag. (default to null)
String *body = string value of the message text - only messages with the text (and specified tag) will be deleted; // 

// Delete messages with specified tag
[apiInstance deleteMessagesWith:tag
    body:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');
var defaultClient = OpenGrokResTfulApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new OpenGrokResTfulApi.MessagesApi()
var tag = tag_example; // {String} Message tag.
var body = string value of the message text - only messages with the text (and specified tag) will be deleted; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new MessagesApi();
            var tag = tag_example;  // String | Message tag. (default to null)
            var body = string value of the message text - only messages with the text (and specified tag) will be deleted;  // String | 

            try {
                // Delete messages with specified tag
                apiInstance.deleteMessages(tag, body);
            } catch (Exception e) {
                Debug.Print("Exception when calling MessagesApi.deleteMessages: " + e.Message );
            }
        }
    }
}

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MessagesApi();
$tag = tag_example; // String | Message tag.
$body = string value of the message text - only messages with the text (and specified tag) will be deleted; // String | 

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

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MessagesApi->new();
my $tag = tag_example; # String | Message tag.
my $body = WWW::OPenAPIClient::Object::String->new(); # String | 

eval {
    $api_instance->deleteMessages(tag => $tag, body => $body);
};
if ($@) {
    warn "Exception when calling MessagesApi->deleteMessages: $@\n";
}

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

# Configure Bearer (token) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.MessagesApi()
tag = tag_example # String | Message tag. (default to null)
body = string value of the message text - only messages with the text (and specified tag) will be deleted # String | 

try:
    # Delete messages with specified tag
    api_instance.delete_messages(tag, body)
except ApiException as e:
    print("Exception when calling MessagesApi->deleteMessages: %s\n" % e)

extern crate MessagesApi;

pub fn main() {
    let tag = tag_example; // String
    let body = string value of the message text - only messages with the text (and specified tag) will be deleted; // String

    let mut context = MessagesApi::Context::default();
    let result = client.deleteMessages(tag, body, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MessagesApi apiInstance = new MessagesApi();
        String tag = tag_example; // String | Message tag.

        try {
            array[Message] result = apiInstance.getMessages(tag);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagesApi#getMessages");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String tag = new String(); // String | Message tag.

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

import org.openapitools.client.api.MessagesApi;

public class MessagesApiExample {
    public static void main(String[] args) {
        MessagesApi apiInstance = new MessagesApi();
        String tag = tag_example; // String | Message tag.

        try {
            array[Message] result = apiInstance.getMessages(tag);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagesApi#getMessages");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
MessagesApi *apiInstance = [[MessagesApi alloc] init];
String *tag = tag_example; // Message tag. (default to null)

// Return all messages with specified tag
[apiInstance getMessagesWith:tag
              completionHandler: ^(array[Message] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');

// Create an instance of the API class
var api = new OpenGrokResTfulApi.MessagesApi()
var tag = tag_example; // {String} Message tag.

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

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

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

            // Create an instance of the API class
            var apiInstance = new MessagesApi();
            var tag = tag_example;  // String | Message tag. (default to null)

            try {
                // Return all messages with specified tag
                array[Message] result = apiInstance.getMessages(tag);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MessagesApi.getMessages: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MessagesApi();
$tag = tag_example; // String | Message tag.

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MessagesApi->new();
my $tag = tag_example; # String | Message tag.

eval {
    my $result = $api_instance->getMessages(tag => $tag);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MessagesApi->getMessages: $@\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.MessagesApi()
tag = tag_example # String | Message tag. (default to null)

try:
    # Return all messages with specified tag
    api_response = api_instance.get_messages(tag)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MessagesApi->getMessages: %s\n" % e)

extern crate MessagesApi;

pub fn main() {
    let tag = tag_example; // String

    let mut context = MessagesApi::Context::default();
    let result = client.getMessages(tag, &context).wait();

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

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

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

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

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

        try {
            'String' result = apiInstance.getPrometheusMetrics();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#getPrometheusMetrics");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.MonitoringApi;

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

        try {
            'String' result = apiInstance.getPrometheusMetrics();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#getPrometheusMetrics");
            e.printStackTrace();
        }
    }
}

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

// Retrieve web application metrics in Prometheus format
[apiInstance getPrometheusMetricsWithCompletionHandler: 
              ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');

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

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

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

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

            try {
                // Retrieve web application metrics in Prometheus format
                'String' result = apiInstance.getPrometheusMetrics();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.getPrometheusMetrics: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->getPrometheusMetrics();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->getPrometheusMetrics: $@\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.MonitoringApi()

try:
    # Retrieve web application metrics in Prometheus format
    api_response = api_instance.get_prometheus_metrics()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->getPrometheusMetrics: %s\n" % e)

extern crate MonitoringApi;

pub fn main() {

    let mut context = MonitoringApi::Context::default();
    let result = client.getPrometheusMetrics(&context).wait();

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

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

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

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

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

        // Create an instance of the API class
        ProjectsApi apiInstance = new ProjectsApi();
        String body = text/plain name of the project; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String body = new String(); // String | 

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

import org.openapitools.client.api.ProjectsApi;

public class ProjectsApiExample {
    public static void main(String[] args) {
        ProjectsApi apiInstance = new ProjectsApi();
        String body = text/plain name of the project; // String | 

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

Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
ProjectsApi *apiInstance = [[ProjectsApi alloc] init];
String *body = text/plain name of the project; // 

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

var OpenGrokResTfulApi = require('open_grok_res_tful_api');
var defaultClient = OpenGrokResTfulApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new OpenGrokResTfulApi.ProjectsApi()
var body = text/plain name of the project; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProjectsApi();
            var body = text/plain name of the project;  // String | 

            try {
                // Add project
                apiInstance.addProject(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProjectsApi.addProject: " + e.Message );
            }
        }
    }
}

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProjectsApi();
$body = text/plain name of the project; // String | 

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

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

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

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

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

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

# Configure Bearer (token) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ProjectsApi()
body = text/plain name of the project # String | 

try:
    # Add project
    api_instance.add_project(body)
except ApiException as e:
    print("Exception when calling ProjectsApi->addProject: %s\n" % e)

extern crate ProjectsApi;

pub fn main() {
    let body = text/plain name of the project; // String

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

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

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

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

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

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

        // Create an instance of the API class
        ProjectsApi apiInstance = new ProjectsApi();
        String project = project_example; // String | Project name.

        try {
            apiInstance.deleteProject(project);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#deleteProject");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String project = new String(); // String | Project name.

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

import org.openapitools.client.api.ProjectsApi;

public class ProjectsApiExample {
    public static void main(String[] args) {
        ProjectsApi apiInstance = new ProjectsApi();
        String project = project_example; // String | Project name.

        try {
            apiInstance.deleteProject(project);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#deleteProject");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
ProjectsApi *apiInstance = [[ProjectsApi alloc] init];
String *project = project_example; // Project name. (default to null)

// Delete project
[apiInstance deleteProjectWith:project
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');
var defaultClient = OpenGrokResTfulApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new OpenGrokResTfulApi.ProjectsApi()
var project = project_example; // {String} Project name.

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProjectsApi();
            var project = project_example;  // String | Project name. (default to null)

            try {
                // Delete project
                apiInstance.deleteProject(project);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProjectsApi.deleteProject: " + e.Message );
            }
        }
    }
}

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProjectsApi();
$project = project_example; // String | Project name.

try {
    $api_instance->deleteProject($project);
} catch (Exception $e) {
    echo 'Exception when calling ProjectsApi->deleteProject: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProjectsApi->new();
my $project = project_example; # String | Project name.

eval {
    $api_instance->deleteProject(project => $project);
};
if ($@) {
    warn "Exception when calling ProjectsApi->deleteProject: $@\n";
}

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

# Configure Bearer (token) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ProjectsApi()
project = project_example # String | Project name. (default to null)

try:
    # Delete project
    api_instance.delete_project(project)
except ApiException as e:
    print("Exception when calling ProjectsApi->deleteProject: %s\n" % e)

extern crate ProjectsApi;

pub fn main() {
    let project = project_example; // String

    let mut context = ProjectsApi::Context::default();
    let result = client.deleteProject(project, &context).wait();

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

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

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

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

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

        // Create an instance of the API class
        ProjectsApi apiInstance = new ProjectsApi();
        String project = project_example; // String | Project name.

        try {
            array['String'] result = apiInstance.deleteProjectAnnotationCache(project);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#deleteProjectAnnotationCache");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String project = new String(); // String | Project name.

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

import org.openapitools.client.api.ProjectsApi;

public class ProjectsApiExample {
    public static void main(String[] args) {
        ProjectsApi apiInstance = new ProjectsApi();
        String project = project_example; // String | Project name.

        try {
            array['String'] result = apiInstance.deleteProjectAnnotationCache(project);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#deleteProjectAnnotationCache");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
ProjectsApi *apiInstance = [[ProjectsApi alloc] init];
String *project = project_example; // Project name. (default to null)

// Delete annotation cache for a project
[apiInstance deleteProjectAnnotationCacheWith:project
              completionHandler: ^(array['String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');
var defaultClient = OpenGrokResTfulApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new OpenGrokResTfulApi.ProjectsApi()
var project = project_example; // {String} Project name.

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProjectsApi();
            var project = project_example;  // String | Project name. (default to null)

            try {
                // Delete annotation cache for a project
                array['String'] result = apiInstance.deleteProjectAnnotationCache(project);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProjectsApi.deleteProjectAnnotationCache: " + e.Message );
            }
        }
    }
}

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProjectsApi();
$project = project_example; // String | Project name.

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

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProjectsApi->new();
my $project = project_example; # String | Project name.

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

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

# Configure Bearer (token) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ProjectsApi()
project = project_example # String | Project name. (default to null)

try:
    # Delete annotation cache for a project
    api_response = api_instance.delete_project_annotation_cache(project)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProjectsApi->deleteProjectAnnotationCache: %s\n" % e)

extern crate ProjectsApi;

pub fn main() {
    let project = project_example; // String

    let mut context = ProjectsApi::Context::default();
    let result = client.deleteProjectAnnotationCache(project, &context).wait();

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

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

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

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

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

        // Create an instance of the API class
        ProjectsApi apiInstance = new ProjectsApi();
        String project = project_example; // String | Project name.

        try {
            apiInstance.deleteProjectData(project);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#deleteProjectData");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String project = new String(); // String | Project name.

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

import org.openapitools.client.api.ProjectsApi;

public class ProjectsApiExample {
    public static void main(String[] args) {
        ProjectsApi apiInstance = new ProjectsApi();
        String project = project_example; // String | Project name.

        try {
            apiInstance.deleteProjectData(project);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#deleteProjectData");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
ProjectsApi *apiInstance = [[ProjectsApi alloc] init];
String *project = project_example; // Project name. (default to null)

// Delete project index data
[apiInstance deleteProjectDataWith:project
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');
var defaultClient = OpenGrokResTfulApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new OpenGrokResTfulApi.ProjectsApi()
var project = project_example; // {String} Project name.

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProjectsApi();
            var project = project_example;  // String | Project name. (default to null)

            try {
                // Delete project index data
                apiInstance.deleteProjectData(project);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProjectsApi.deleteProjectData: " + e.Message );
            }
        }
    }
}

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProjectsApi();
$project = project_example; // String | Project name.

try {
    $api_instance->deleteProjectData($project);
} catch (Exception $e) {
    echo 'Exception when calling ProjectsApi->deleteProjectData: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProjectsApi->new();
my $project = project_example; # String | Project name.

eval {
    $api_instance->deleteProjectData(project => $project);
};
if ($@) {
    warn "Exception when calling ProjectsApi->deleteProjectData: $@\n";
}

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

# Configure Bearer (token) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ProjectsApi()
project = project_example # String | Project name. (default to null)

try:
    # Delete project index data
    api_instance.delete_project_data(project)
except ApiException as e:
    print("Exception when calling ProjectsApi->deleteProjectData: %s\n" % e)

extern crate ProjectsApi;

pub fn main() {
    let project = project_example; // String

    let mut context = ProjectsApi::Context::default();
    let result = client.deleteProjectData(project, &context).wait();

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

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

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

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

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

        // Create an instance of the API class
        ProjectsApi apiInstance = new ProjectsApi();
        String project = project_example; // String | Project name.

        try {
            array['String'] result = apiInstance.deleteProjectHistoryCache(project);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#deleteProjectHistoryCache");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String project = new String(); // String | Project name.

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

import org.openapitools.client.api.ProjectsApi;

public class ProjectsApiExample {
    public static void main(String[] args) {
        ProjectsApi apiInstance = new ProjectsApi();
        String project = project_example; // String | Project name.

        try {
            array['String'] result = apiInstance.deleteProjectHistoryCache(project);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#deleteProjectHistoryCache");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
ProjectsApi *apiInstance = [[ProjectsApi alloc] init];
String *project = project_example; // Project name. (default to null)

// Delete history cache for a project
[apiInstance deleteProjectHistoryCacheWith:project
              completionHandler: ^(array['String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');
var defaultClient = OpenGrokResTfulApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new OpenGrokResTfulApi.ProjectsApi()
var project = project_example; // {String} Project name.

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProjectsApi();
            var project = project_example;  // String | Project name. (default to null)

            try {
                // Delete history cache for a project
                array['String'] result = apiInstance.deleteProjectHistoryCache(project);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProjectsApi.deleteProjectHistoryCache: " + e.Message );
            }
        }
    }
}

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProjectsApi();
$project = project_example; // String | Project name.

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

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProjectsApi->new();
my $project = project_example; # String | Project name.

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

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

# Configure Bearer (token) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ProjectsApi()
project = project_example # String | Project name. (default to null)

try:
    # Delete history cache for a project
    api_response = api_instance.delete_project_history_cache(project)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProjectsApi->deleteProjectHistoryCache: %s\n" % e)

extern crate ProjectsApi;

pub fn main() {
    let project = project_example; // String

    let mut context = ProjectsApi::Context::default();
    let result = client.deleteProjectHistoryCache(project, &context).wait();

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

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

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

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

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

        try {
            array['String'] result = apiInstance.getIndexedProjects();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#getIndexedProjects");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.ProjectsApi;

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

        try {
            array['String'] result = apiInstance.getIndexedProjects();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#getIndexedProjects");
            e.printStackTrace();
        }
    }
}

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

// Return a list of indexed projects
[apiInstance getIndexedProjectsWithCompletionHandler: 
              ^(array['String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');

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

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

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

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

            try {
                // Return a list of indexed projects
                array['String'] result = apiInstance.getIndexedProjects();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProjectsApi.getIndexedProjects: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->getIndexedProjects();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProjectsApi->getIndexedProjects: $@\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.ProjectsApi()

try:
    # Return a list of indexed projects
    api_response = api_instance.get_indexed_projects()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProjectsApi->getIndexedProjects: %s\n" % e)

extern crate ProjectsApi;

pub fn main() {

    let mut context = ProjectsApi::Context::default();
    let result = client.getIndexedProjects(&context).wait();

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

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

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

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

        // Create an instance of the API class
        ProjectsApi apiInstance = new ProjectsApi();
        String project = project_example; // String | Project name.

        try {
            array['String'] result = apiInstance.getProjectFiles(project);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#getProjectFiles");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String project = new String(); // String | Project name.

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

import org.openapitools.client.api.ProjectsApi;

public class ProjectsApiExample {
    public static void main(String[] args) {
        ProjectsApi apiInstance = new ProjectsApi();
        String project = project_example; // String | Project name.

        try {
            array['String'] result = apiInstance.getProjectFiles(project);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#getProjectFiles");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ProjectsApi *apiInstance = [[ProjectsApi alloc] init];
String *project = project_example; // Project name. (default to null)

// Get list of files tracked by the index database for given project
[apiInstance getProjectFilesWith:project
              completionHandler: ^(array['String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');

// Create an instance of the API class
var api = new OpenGrokResTfulApi.ProjectsApi()
var project = project_example; // {String} Project name.

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProjectsApi();
            var project = project_example;  // String | Project name. (default to null)

            try {
                // Get list of files tracked by the index database for given project
                array['String'] result = apiInstance.getProjectFiles(project);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProjectsApi.getProjectFiles: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProjectsApi();
$project = project_example; // String | Project name.

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProjectsApi->new();
my $project = project_example; # String | Project name.

eval {
    my $result = $api_instance->getProjectFiles(project => $project);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProjectsApi->getProjectFiles: $@\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.ProjectsApi()
project = project_example # String | Project name. (default to null)

try:
    # Get list of files tracked by the index database for given project
    api_response = api_instance.get_project_files(project)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProjectsApi->getProjectFiles: %s\n" % e)

extern crate ProjectsApi;

pub fn main() {
    let project = project_example; // String

    let mut context = ProjectsApi::Context::default();
    let result = client.getProjectFiles(project, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ProjectsApi apiInstance = new ProjectsApi();
        String project = project_example; // String | Project name.
        String propertyname = propertyname_example; // String | Property name.

        try {
            oas_any_type_not_mapped result = apiInstance.getProjectProperty(project, propertyname);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#getProjectProperty");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String project = new String(); // String | Project name.
final String propertyname = new String(); // String | Property name.

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

import org.openapitools.client.api.ProjectsApi;

public class ProjectsApiExample {
    public static void main(String[] args) {
        ProjectsApi apiInstance = new ProjectsApi();
        String project = project_example; // String | Project name.
        String propertyname = propertyname_example; // String | Property name.

        try {
            oas_any_type_not_mapped result = apiInstance.getProjectProperty(project, propertyname);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#getProjectProperty");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ProjectsApi *apiInstance = [[ProjectsApi alloc] init];
String *project = project_example; // Project name. (default to null)
String *propertyname = propertyname_example; // Property name. (default to null)

// Return the property value
[apiInstance getProjectPropertyWith:project
    propertyname:propertyname
              completionHandler: ^(oas_any_type_not_mapped output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');

// Create an instance of the API class
var api = new OpenGrokResTfulApi.ProjectsApi()
var project = project_example; // {String} Project name.
var propertyname = propertyname_example; // {String} Property name.

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProjectsApi();
            var project = project_example;  // String | Project name. (default to null)
            var propertyname = propertyname_example;  // String | Property name. (default to null)

            try {
                // Return the property value
                oas_any_type_not_mapped result = apiInstance.getProjectProperty(project, propertyname);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProjectsApi.getProjectProperty: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProjectsApi();
$project = project_example; // String | Project name.
$propertyname = propertyname_example; // String | Property name.

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProjectsApi->new();
my $project = project_example; # String | Project name.
my $propertyname = propertyname_example; # String | Property name.

eval {
    my $result = $api_instance->getProjectProperty(project => $project, propertyname => $propertyname);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProjectsApi->getProjectProperty: $@\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.ProjectsApi()
project = project_example # String | Project name. (default to null)
propertyname = propertyname_example # String | Property name. (default to null)

try:
    # Return the property value
    api_response = api_instance.get_project_property(project, propertyname)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProjectsApi->getProjectProperty: %s\n" % e)

extern crate ProjectsApi;

pub fn main() {
    let project = project_example; // String
    let propertyname = propertyname_example; // String

    let mut context = ProjectsApi::Context::default();
    let result = client.getProjectProperty(project, propertyname, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ProjectsApi apiInstance = new ProjectsApi();
        String project = project_example; // String | Project name.

        try {
            array['String'] result = apiInstance.getProjectRepositories(project);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#getProjectRepositories");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String project = new String(); // String | Project name.

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

import org.openapitools.client.api.ProjectsApi;

public class ProjectsApiExample {
    public static void main(String[] args) {
        ProjectsApi apiInstance = new ProjectsApi();
        String project = project_example; // String | Project name.

        try {
            array['String'] result = apiInstance.getProjectRepositories(project);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#getProjectRepositories");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ProjectsApi *apiInstance = [[ProjectsApi alloc] init];
String *project = project_example; // Project name. (default to null)

// Return a list of repositories for the specified project
[apiInstance getProjectRepositoriesWith:project
              completionHandler: ^(array['String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');

// Create an instance of the API class
var api = new OpenGrokResTfulApi.ProjectsApi()
var project = project_example; // {String} Project name.

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProjectsApi();
            var project = project_example;  // String | Project name. (default to null)

            try {
                // Return a list of repositories for the specified project
                array['String'] result = apiInstance.getProjectRepositories(project);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProjectsApi.getProjectRepositories: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProjectsApi();
$project = project_example; // String | Project name.

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProjectsApi->new();
my $project = project_example; # String | Project name.

eval {
    my $result = $api_instance->getProjectRepositories(project => $project);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProjectsApi->getProjectRepositories: $@\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.ProjectsApi()
project = project_example # String | Project name. (default to null)

try:
    # Return a list of repositories for the specified project
    api_response = api_instance.get_project_repositories(project)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProjectsApi->getProjectRepositories: %s\n" % e)

extern crate ProjectsApi;

pub fn main() {
    let project = project_example; // String

    let mut context = ProjectsApi::Context::default();
    let result = client.getProjectRepositories(project, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ProjectsApi apiInstance = new ProjectsApi();
        String project = project_example; // String | Project name.

        try {
            array['String'] result = apiInstance.getProjectRepositoryTypes(project);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#getProjectRepositoryTypes");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String project = new String(); // String | Project name.

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

import org.openapitools.client.api.ProjectsApi;

public class ProjectsApiExample {
    public static void main(String[] args) {
        ProjectsApi apiInstance = new ProjectsApi();
        String project = project_example; // String | Project name.

        try {
            array['String'] result = apiInstance.getProjectRepositoryTypes(project);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#getProjectRepositoryTypes");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ProjectsApi *apiInstance = [[ProjectsApi alloc] init];
String *project = project_example; // Project name. (default to null)

// Return types of project repositories
[apiInstance getProjectRepositoryTypesWith:project
              completionHandler: ^(array['String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');

// Create an instance of the API class
var api = new OpenGrokResTfulApi.ProjectsApi()
var project = project_example; // {String} Project name.

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProjectsApi();
            var project = project_example;  // String | Project name. (default to null)

            try {
                // Return types of project repositories
                array['String'] result = apiInstance.getProjectRepositoryTypes(project);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProjectsApi.getProjectRepositoryTypes: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProjectsApi();
$project = project_example; // String | Project name.

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProjectsApi->new();
my $project = project_example; # String | Project name.

eval {
    my $result = $api_instance->getProjectRepositoryTypes(project => $project);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProjectsApi->getProjectRepositoryTypes: $@\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.ProjectsApi()
project = project_example # String | Project name. (default to null)

try:
    # Return types of project repositories
    api_response = api_instance.get_project_repository_types(project)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProjectsApi->getProjectRepositoryTypes: %s\n" % e)

extern crate ProjectsApi;

pub fn main() {
    let project = project_example; // String

    let mut context = ProjectsApi::Context::default();
    let result = client.getProjectRepositoryTypes(project, &context).wait();

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

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

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

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

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

        try {
            array['String'] result = apiInstance.getProjects();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#getProjects");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.ProjectsApi;

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

        try {
            array['String'] result = apiInstance.getProjects();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#getProjects");
            e.printStackTrace();
        }
    }
}

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

// Return a list of all projects
[apiInstance getProjectsWithCompletionHandler: 
              ^(array['String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');

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

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

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

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

            try {
                // Return a list of all projects
                array['String'] result = apiInstance.getProjects();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProjectsApi.getProjects: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->getProjects();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProjectsApi->getProjects: $@\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.ProjectsApi()

try:
    # Return a list of all projects
    api_response = api_instance.get_projects()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProjectsApi->getProjects: %s\n" % e)

extern crate ProjectsApi;

pub fn main() {

    let mut context = ProjectsApi::Context::default();
    let result = client.getProjects(&context).wait();

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

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

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

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

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

        // Create an instance of the API class
        ProjectsApi apiInstance = new ProjectsApi();
        String project = project_example; // String | Project name.
        String body = ; // String | 

        try {
            apiInstance.markProjectIndexed(project, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#markProjectIndexed");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String project = new String(); // String | Project name.
final String body = new String(); // String | 

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

import org.openapitools.client.api.ProjectsApi;

public class ProjectsApiExample {
    public static void main(String[] args) {
        ProjectsApi apiInstance = new ProjectsApi();
        String project = project_example; // String | Project name.
        String body = ; // String | 

        try {
            apiInstance.markProjectIndexed(project, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#markProjectIndexed");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
ProjectsApi *apiInstance = [[ProjectsApi alloc] init];
String *project = project_example; // Project name. (default to null)
String *body = ; //  (optional)

// Mark project as indexed
[apiInstance markProjectIndexedWith:project
    body:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');
var defaultClient = OpenGrokResTfulApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new OpenGrokResTfulApi.ProjectsApi()
var project = project_example; // {String} Project name.
var opts = {
  'body':  // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProjectsApi();
            var project = project_example;  // String | Project name. (default to null)
            var body = ;  // String |  (optional) 

            try {
                // Mark project as indexed
                apiInstance.markProjectIndexed(project, body);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProjectsApi.markProjectIndexed: " + e.Message );
            }
        }
    }
}

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProjectsApi();
$project = project_example; // String | Project name.
$body = ; // String | 

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

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProjectsApi->new();
my $project = project_example; # String | Project name.
my $body = WWW::OPenAPIClient::Object::String->new(); # String | 

eval {
    $api_instance->markProjectIndexed(project => $project, body => $body);
};
if ($@) {
    warn "Exception when calling ProjectsApi->markProjectIndexed: $@\n";
}

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

# Configure Bearer (token) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ProjectsApi()
project = project_example # String | Project name. (default to null)
body =  # String |  (optional)

try:
    # Mark project as indexed
    api_instance.mark_project_indexed(project, body=body)
except ApiException as e:
    print("Exception when calling ProjectsApi->markProjectIndexed: %s\n" % e)

extern crate ProjectsApi;

pub fn main() {
    let project = project_example; // String
    let body = ; // String

    let mut context = ProjectsApi::Context::default();
    let result = client.markProjectIndexed(project, body, &context).wait();

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

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

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

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

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

        // Create an instance of the API class
        ProjectsApi apiInstance = new ProjectsApi();
        String project = project_example; // String | Project name.
        String propertyname = propertyname_example; // String | Property name.
        String body = body - string representation of the value to set; // String | 

        try {
            apiInstance.setProjectProperty(project, propertyname, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#setProjectProperty");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String project = new String(); // String | Project name.
final String propertyname = new String(); // String | Property name.
final String body = new String(); // String | 

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

import org.openapitools.client.api.ProjectsApi;

public class ProjectsApiExample {
    public static void main(String[] args) {
        ProjectsApi apiInstance = new ProjectsApi();
        String project = project_example; // String | Project name.
        String propertyname = propertyname_example; // String | Property name.
        String body = body - string representation of the value to set; // String | 

        try {
            apiInstance.setProjectProperty(project, propertyname, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#setProjectProperty");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
ProjectsApi *apiInstance = [[ProjectsApi alloc] init];
String *project = project_example; // Project name. (default to null)
String *propertyname = propertyname_example; // Property name. (default to null)
String *body = body - string representation of the value to set; // 

// Set property value for the project
[apiInstance setProjectPropertyWith:project
    propertyname:propertyname
    body:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');
var defaultClient = OpenGrokResTfulApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new OpenGrokResTfulApi.ProjectsApi()
var project = project_example; // {String} Project name.
var propertyname = propertyname_example; // {String} Property name.
var body = body - string representation of the value to set; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProjectsApi();
            var project = project_example;  // String | Project name. (default to null)
            var propertyname = propertyname_example;  // String | Property name. (default to null)
            var body = body - string representation of the value to set;  // String | 

            try {
                // Set property value for the project
                apiInstance.setProjectProperty(project, propertyname, body);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProjectsApi.setProjectProperty: " + e.Message );
            }
        }
    }
}

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProjectsApi();
$project = project_example; // String | Project name.
$propertyname = propertyname_example; // String | Property name.
$body = body - string representation of the value to set; // String | 

try {
    $api_instance->setProjectProperty($project, $propertyname, $body);
} catch (Exception $e) {
    echo 'Exception when calling ProjectsApi->setProjectProperty: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProjectsApi->new();
my $project = project_example; # String | Project name.
my $propertyname = propertyname_example; # String | Property name.
my $body = WWW::OPenAPIClient::Object::String->new(); # String | 

eval {
    $api_instance->setProjectProperty(project => $project, propertyname => $propertyname, body => $body);
};
if ($@) {
    warn "Exception when calling ProjectsApi->setProjectProperty: $@\n";
}

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

# Configure Bearer (token) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ProjectsApi()
project = project_example # String | Project name. (default to null)
propertyname = propertyname_example # String | Property name. (default to null)
body = body - string representation of the value to set # String | 

try:
    # Set property value for the project
    api_instance.set_project_property(project, propertyname, body)
except ApiException as e:
    print("Exception when calling ProjectsApi->setProjectProperty: %s\n" % e)

extern crate ProjectsApi;

pub fn main() {
    let project = project_example; // String
    let propertyname = propertyname_example; // String
    let body = body - string representation of the value to set; // String

    let mut context = ProjectsApi::Context::default();
    let result = client.setProjectProperty(project, propertyname, body, &context).wait();

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

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

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

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

        // Create an instance of the API class
        RepositoriesApi apiInstance = new RepositoriesApi();
        String field = field_example; // String | Repository field name.
        String repository = repository_example; // String | Repository path with native path separators of the machine running the service, starting with path separator.

        try {
            oas_any_type_not_mapped result = apiInstance.getRepositoryProperty(field, repository);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RepositoriesApi#getRepositoryProperty");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String field = new String(); // String | Repository field name.
final String repository = new String(); // String | Repository path with native path separators of the machine running the service, starting with path separator.

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

import org.openapitools.client.api.RepositoriesApi;

public class RepositoriesApiExample {
    public static void main(String[] args) {
        RepositoriesApi apiInstance = new RepositoriesApi();
        String field = field_example; // String | Repository field name.
        String repository = repository_example; // String | Repository path with native path separators of the machine running the service, starting with path separator.

        try {
            oas_any_type_not_mapped result = apiInstance.getRepositoryProperty(field, repository);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RepositoriesApi#getRepositoryProperty");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
RepositoriesApi *apiInstance = [[RepositoriesApi alloc] init];
String *field = field_example; // Repository field name. (default to null)
String *repository = repository_example; // Repository path with native path separators of the machine running the service, starting with path separator. (default to null)

// Return the repository field value
[apiInstance getRepositoryPropertyWith:field
    repository:repository
              completionHandler: ^(oas_any_type_not_mapped output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');

// Create an instance of the API class
var api = new OpenGrokResTfulApi.RepositoriesApi()
var field = field_example; // {String} Repository field name.
var repository = repository_example; // {String} Repository path with native path separators of the machine running the service, starting with path separator.

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

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

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

            // Create an instance of the API class
            var apiInstance = new RepositoriesApi();
            var field = field_example;  // String | Repository field name. (default to null)
            var repository = repository_example;  // String | Repository path with native path separators of the machine running the service, starting with path separator. (default to null)

            try {
                // Return the repository field value
                oas_any_type_not_mapped result = apiInstance.getRepositoryProperty(field, repository);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RepositoriesApi.getRepositoryProperty: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RepositoriesApi();
$field = field_example; // String | Repository field name.
$repository = repository_example; // String | Repository path with native path separators of the machine running the service, starting with path separator.

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RepositoriesApi->new();
my $field = field_example; # String | Repository field name.
my $repository = repository_example; # String | Repository path with native path separators of the machine running the service, starting with path separator.

eval {
    my $result = $api_instance->getRepositoryProperty(field => $field, repository => $repository);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RepositoriesApi->getRepositoryProperty: $@\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.RepositoriesApi()
field = field_example # String | Repository field name. (default to null)
repository = repository_example # String | Repository path with native path separators of the machine running the service, starting with path separator. (default to null)

try:
    # Return the repository field value
    api_response = api_instance.get_repository_property(field, repository)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RepositoriesApi->getRepositoryProperty: %s\n" % e)

extern crate RepositoriesApi;

pub fn main() {
    let field = field_example; // String
    let repository = repository_example; // String

    let mut context = RepositoriesApi::Context::default();
    let result = client.getRepositoryProperty(field, repository, &context).wait();

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

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

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

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

        // Create an instance of the API class
        SearchApi apiInstance = new SearchApi();
        String full = full_example; // String | Full search field value to search for.
        String def = def_example; // String | Definition field value to search for.
        String symbol = symbol_example; // String | Symbol field value to search for.
        String path = path_example; // String | File path field value to search for.
        String hist = hist_example; // String | History field value to search for.
        String type = type_example; // String | Type of files to search for.
        String projects = projects_example; // String | Projects to search in.
        Integer maxresults = 56; // Integer | Maximum number of documents whose hits will be returned.
        Integer start = 56; // Integer | Start index from which to return results.
        Integer maxhitsperfile = 56; // Integer | Maximum number of matching lines returned per file. `0` returns all matching lines.
        String sort = sort_example; // String | Sort order for results.

        try {
            SearchResponse result = apiInstance.search(full, def, symbol, path, hist, type, projects, maxresults, start, maxhitsperfile, sort);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SearchApi#search");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String full = new String(); // String | Full search field value to search for.
final String def = new String(); // String | Definition field value to search for.
final String symbol = new String(); // String | Symbol field value to search for.
final String path = new String(); // String | File path field value to search for.
final String hist = new String(); // String | History field value to search for.
final String type = new String(); // String | Type of files to search for.
final String projects = new String(); // String | Projects to search in.
final Integer maxresults = new Integer(); // Integer | Maximum number of documents whose hits will be returned.
final Integer start = new Integer(); // Integer | Start index from which to return results.
final Integer maxhitsperfile = new Integer(); // Integer | Maximum number of matching lines returned per file. `0` returns all matching lines.
final String sort = new String(); // String | Sort order for results.

try {
    final result = await api_instance.search(full, def, symbol, path, hist, type, projects, maxresults, start, maxhitsperfile, sort);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->search: $e\n');
}

import org.openapitools.client.api.SearchApi;

public class SearchApiExample {
    public static void main(String[] args) {
        SearchApi apiInstance = new SearchApi();
        String full = full_example; // String | Full search field value to search for.
        String def = def_example; // String | Definition field value to search for.
        String symbol = symbol_example; // String | Symbol field value to search for.
        String path = path_example; // String | File path field value to search for.
        String hist = hist_example; // String | History field value to search for.
        String type = type_example; // String | Type of files to search for.
        String projects = projects_example; // String | Projects to search in.
        Integer maxresults = 56; // Integer | Maximum number of documents whose hits will be returned.
        Integer start = 56; // Integer | Start index from which to return results.
        Integer maxhitsperfile = 56; // Integer | Maximum number of matching lines returned per file. `0` returns all matching lines.
        String sort = sort_example; // String | Sort order for results.

        try {
            SearchResponse result = apiInstance.search(full, def, symbol, path, hist, type, projects, maxresults, start, maxhitsperfile, sort);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SearchApi#search");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
SearchApi *apiInstance = [[SearchApi alloc] init];
String *full = full_example; // Full search field value to search for. (optional) (default to null)
String *def = def_example; // Definition field value to search for. (optional) (default to null)
String *symbol = symbol_example; // Symbol field value to search for. (optional) (default to null)
String *path = path_example; // File path field value to search for. (optional) (default to null)
String *hist = hist_example; // History field value to search for. (optional) (default to null)
String *type = type_example; // Type of files to search for. (optional) (default to null)
String *projects = projects_example; // Projects to search in. (optional) (default to null)
Integer *maxresults = 56; // Maximum number of documents whose hits will be returned. (optional) (default to 1000)
Integer *start = 56; // Start index from which to return results. (optional) (default to null)
Integer *maxhitsperfile = 56; // Maximum number of matching lines returned per file. `0` returns all matching lines. (optional) (default to 0)
String *sort = sort_example; // Sort order for results. (optional) (default to relevancy)

// Return search results
[apiInstance searchWith:full
    def:def
    symbol:symbol
    path:path
    hist:hist
    type:type
    projects:projects
    maxresults:maxresults
    start:start
    maxhitsperfile:maxhitsperfile
    sort:sort
              completionHandler: ^(SearchResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');

// Create an instance of the API class
var api = new OpenGrokResTfulApi.SearchApi()
var opts = {
  'full': full_example, // {String} Full search field value to search for.
  'def': def_example, // {String} Definition field value to search for.
  'symbol': symbol_example, // {String} Symbol field value to search for.
  'path': path_example, // {String} File path field value to search for.
  'hist': hist_example, // {String} History field value to search for.
  'type': type_example, // {String} Type of files to search for.
  'projects': projects_example, // {String} Projects to search in.
  'maxresults': 56, // {Integer} Maximum number of documents whose hits will be returned.
  'start': 56, // {Integer} Start index from which to return results.
  'maxhitsperfile': 56, // {Integer} Maximum number of matching lines returned per file. `0` returns all matching lines.
  'sort': sort_example // {String} Sort order for results.
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new SearchApi();
            var full = full_example;  // String | Full search field value to search for. (optional)  (default to null)
            var def = def_example;  // String | Definition field value to search for. (optional)  (default to null)
            var symbol = symbol_example;  // String | Symbol field value to search for. (optional)  (default to null)
            var path = path_example;  // String | File path field value to search for. (optional)  (default to null)
            var hist = hist_example;  // String | History field value to search for. (optional)  (default to null)
            var type = type_example;  // String | Type of files to search for. (optional)  (default to null)
            var projects = projects_example;  // String | Projects to search in. (optional)  (default to null)
            var maxresults = 56;  // Integer | Maximum number of documents whose hits will be returned. (optional)  (default to 1000)
            var start = 56;  // Integer | Start index from which to return results. (optional)  (default to null)
            var maxhitsperfile = 56;  // Integer | Maximum number of matching lines returned per file. `0` returns all matching lines. (optional)  (default to 0)
            var sort = sort_example;  // String | Sort order for results. (optional)  (default to relevancy)

            try {
                // Return search results
                SearchResponse result = apiInstance.search(full, def, symbol, path, hist, type, projects, maxresults, start, maxhitsperfile, sort);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SearchApi.search: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SearchApi();
$full = full_example; // String | Full search field value to search for.
$def = def_example; // String | Definition field value to search for.
$symbol = symbol_example; // String | Symbol field value to search for.
$path = path_example; // String | File path field value to search for.
$hist = hist_example; // String | History field value to search for.
$type = type_example; // String | Type of files to search for.
$projects = projects_example; // String | Projects to search in.
$maxresults = 56; // Integer | Maximum number of documents whose hits will be returned.
$start = 56; // Integer | Start index from which to return results.
$maxhitsperfile = 56; // Integer | Maximum number of matching lines returned per file. `0` returns all matching lines.
$sort = sort_example; // String | Sort order for results.

try {
    $result = $api_instance->search($full, $def, $symbol, $path, $hist, $type, $projects, $maxresults, $start, $maxhitsperfile, $sort);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SearchApi->search: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SearchApi->new();
my $full = full_example; # String | Full search field value to search for.
my $def = def_example; # String | Definition field value to search for.
my $symbol = symbol_example; # String | Symbol field value to search for.
my $path = path_example; # String | File path field value to search for.
my $hist = hist_example; # String | History field value to search for.
my $type = type_example; # String | Type of files to search for.
my $projects = projects_example; # String | Projects to search in.
my $maxresults = 56; # Integer | Maximum number of documents whose hits will be returned.
my $start = 56; # Integer | Start index from which to return results.
my $maxhitsperfile = 56; # Integer | Maximum number of matching lines returned per file. `0` returns all matching lines.
my $sort = sort_example; # String | Sort order for results.

eval {
    my $result = $api_instance->search(full => $full, def => $def, symbol => $symbol, path => $path, hist => $hist, type => $type, projects => $projects, maxresults => $maxresults, start => $start, maxhitsperfile => $maxhitsperfile, sort => $sort);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SearchApi->search: $@\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.SearchApi()
full = full_example # String | Full search field value to search for. (optional) (default to null)
def = def_example # String | Definition field value to search for. (optional) (default to null)
symbol = symbol_example # String | Symbol field value to search for. (optional) (default to null)
path = path_example # String | File path field value to search for. (optional) (default to null)
hist = hist_example # String | History field value to search for. (optional) (default to null)
type = type_example # String | Type of files to search for. (optional) (default to null)
projects = projects_example # String | Projects to search in. (optional) (default to null)
maxresults = 56 # Integer | Maximum number of documents whose hits will be returned. (optional) (default to 1000)
start = 56 # Integer | Start index from which to return results. (optional) (default to null)
maxhitsperfile = 56 # Integer | Maximum number of matching lines returned per file. `0` returns all matching lines. (optional) (default to 0)
sort = sort_example # String | Sort order for results. (optional) (default to relevancy)

try:
    # Return search results
    api_response = api_instance.search(full=full, def=def, symbol=symbol, path=path, hist=hist, type=type, projects=projects, maxresults=maxresults, start=start, maxhitsperfile=maxhitsperfile, sort=sort)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SearchApi->search: %s\n" % e)

extern crate SearchApi;

pub fn main() {
    let full = full_example; // String
    let def = def_example; // String
    let symbol = symbol_example; // String
    let path = path_example; // String
    let hist = hist_example; // String
    let type = type_example; // String
    let projects = projects_example; // String
    let maxresults = 56; // Integer
    let start = 56; // Integer
    let maxhitsperfile = 56; // Integer
    let sort = sort_example; // String

    let mut context = SearchApi::Context::default();
    let result = client.search(full, def, symbol, path, hist, type, projects, maxresults, start, maxhitsperfile, sort, &context).wait();

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

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

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

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

        // Create an instance of the API class
        StatusApi apiInstance = new StatusApi();
        UUID uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | API request UUID.

        try {
            apiInstance.deleteApiRequestStatus(uuid);
        } catch (ApiException e) {
            System.err.println("Exception when calling StatusApi#deleteApiRequestStatus");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID uuid = new UUID(); // UUID | API request UUID.

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

import org.openapitools.client.api.StatusApi;

public class StatusApiExample {
    public static void main(String[] args) {
        StatusApi apiInstance = new StatusApi();
        UUID uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | API request UUID.

        try {
            apiInstance.deleteApiRequestStatus(uuid);
        } catch (ApiException e) {
            System.err.println("Exception when calling StatusApi#deleteApiRequestStatus");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
StatusApi *apiInstance = [[StatusApi alloc] init];
UUID *uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // API request UUID. (default to null)

// Delete state associated with API request tracking
[apiInstance deleteApiRequestStatusWith:uuid
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');

// Create an instance of the API class
var api = new OpenGrokResTfulApi.StatusApi()
var uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} API request UUID.

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

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

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

            // Create an instance of the API class
            var apiInstance = new StatusApi();
            var uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | API request UUID. (default to null)

            try {
                // Delete state associated with API request tracking
                apiInstance.deleteApiRequestStatus(uuid);
            } catch (Exception e) {
                Debug.Print("Exception when calling StatusApi.deleteApiRequestStatus: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\StatusApi();
$uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | API request UUID.

try {
    $api_instance->deleteApiRequestStatus($uuid);
} catch (Exception $e) {
    echo 'Exception when calling StatusApi->deleteApiRequestStatus: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::StatusApi->new();
my $uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | API request UUID.

eval {
    $api_instance->deleteApiRequestStatus(uuid => $uuid);
};
if ($@) {
    warn "Exception when calling StatusApi->deleteApiRequestStatus: $@\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.StatusApi()
uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | API request UUID. (default to null)

try:
    # Delete state associated with API request tracking
    api_instance.delete_api_request_status(uuid)
except ApiException as e:
    print("Exception when calling StatusApi->deleteApiRequestStatus: %s\n" % e)

extern crate StatusApi;

pub fn main() {
    let uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = StatusApi::Context::default();
    let result = client.deleteApiRequestStatus(uuid, &context).wait();

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

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

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

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

        // Create an instance of the API class
        StatusApi apiInstance = new StatusApi();
        UUID uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | API request UUID.

        try {
            apiInstance.getApiRequestStatus(uuid);
        } catch (ApiException e) {
            System.err.println("Exception when calling StatusApi#getApiRequestStatus");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID uuid = new UUID(); // UUID | API request UUID.

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

import org.openapitools.client.api.StatusApi;

public class StatusApiExample {
    public static void main(String[] args) {
        StatusApi apiInstance = new StatusApi();
        UUID uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | API request UUID.

        try {
            apiInstance.getApiRequestStatus(uuid);
        } catch (ApiException e) {
            System.err.println("Exception when calling StatusApi#getApiRequestStatus");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
StatusApi *apiInstance = [[StatusApi alloc] init];
UUID *uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // API request UUID. (default to null)

// Check the state of an API request
[apiInstance getApiRequestStatusWith:uuid
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');

// Create an instance of the API class
var api = new OpenGrokResTfulApi.StatusApi()
var uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} API request UUID.

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

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

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

            // Create an instance of the API class
            var apiInstance = new StatusApi();
            var uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | API request UUID. (default to null)

            try {
                // Check the state of an API request
                apiInstance.getApiRequestStatus(uuid);
            } catch (Exception e) {
                Debug.Print("Exception when calling StatusApi.getApiRequestStatus: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\StatusApi();
$uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | API request UUID.

try {
    $api_instance->getApiRequestStatus($uuid);
} catch (Exception $e) {
    echo 'Exception when calling StatusApi->getApiRequestStatus: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::StatusApi->new();
my $uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | API request UUID.

eval {
    $api_instance->getApiRequestStatus(uuid => $uuid);
};
if ($@) {
    warn "Exception when calling StatusApi->getApiRequestStatus: $@\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.StatusApi()
uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | API request UUID. (default to null)

try:
    # Check the state of an API request
    api_instance.get_api_request_status(uuid)
except ApiException as e:
    print("Exception when calling StatusApi->getApiRequestStatus: %s\n" % e)

extern crate StatusApi;

pub fn main() {
    let uuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = StatusApi::Context::default();
    let result = client.getApiRequestStatus(uuid, &context).wait();

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

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

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

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

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

        try {
            SuggesterConfig result = apiInstance.getSuggesterConfig();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SuggesterApi#getSuggesterConfig");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.SuggesterApi;

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

        try {
            SuggesterConfig result = apiInstance.getSuggesterConfig();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SuggesterApi#getSuggesterConfig");
            e.printStackTrace();
        }
    }
}

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

// Return suggester configuration
[apiInstance getSuggesterConfigWithCompletionHandler: 
              ^(SuggesterConfig output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');

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

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

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

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

            try {
                // Return suggester configuration
                SuggesterConfig result = apiInstance.getSuggesterConfig();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SuggesterApi.getSuggesterConfig: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->getSuggesterConfig();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SuggesterApi->getSuggesterConfig: $@\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.SuggesterApi()

try:
    # Return suggester configuration
    api_response = api_instance.get_suggester_config()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SuggesterApi->getSuggesterConfig: %s\n" % e)

extern crate SuggesterApi;

pub fn main() {

    let mut context = SuggesterApi::Context::default();
    let result = client.getSuggesterConfig(&context).wait();

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

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

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

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

        // Create an instance of the API class
        SuggesterApi apiInstance = new SuggesterApi();
        String project = project_example; // String | Project name.
        String field = field_example; // String | Field for which to retrieve data.
        Integer page = 56; // Integer | Page of data.
        Integer pageSize = 56; // Integer | Size of the page.
        Boolean all = true; // Boolean | If all data should be retrieved. If true, `page` and `pageSize` are ignored.

        try {
            array[map['String', 'Integer']] result = apiInstance.getSuggesterPopularityData(project, field, page, pageSize, all);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SuggesterApi#getSuggesterPopularityData");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String project = new String(); // String | Project name.
final String field = new String(); // String | Field for which to retrieve data.
final Integer page = new Integer(); // Integer | Page of data.
final Integer pageSize = new Integer(); // Integer | Size of the page.
final Boolean all = new Boolean(); // Boolean | If all data should be retrieved. If true, `page` and `pageSize` are ignored.

try {
    final result = await api_instance.getSuggesterPopularityData(project, field, page, pageSize, all);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getSuggesterPopularityData: $e\n');
}

import org.openapitools.client.api.SuggesterApi;

public class SuggesterApiExample {
    public static void main(String[] args) {
        SuggesterApi apiInstance = new SuggesterApi();
        String project = project_example; // String | Project name.
        String field = field_example; // String | Field for which to retrieve data.
        Integer page = 56; // Integer | Page of data.
        Integer pageSize = 56; // Integer | Size of the page.
        Boolean all = true; // Boolean | If all data should be retrieved. If true, `page` and `pageSize` are ignored.

        try {
            array[map['String', 'Integer']] result = apiInstance.getSuggesterPopularityData(project, field, page, pageSize, all);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SuggesterApi#getSuggesterPopularityData");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
SuggesterApi *apiInstance = [[SuggesterApi alloc] init];
String *project = project_example; // Project name. (default to null)
String *field = field_example; // Field for which to retrieve data. (optional) (default to full)
Integer *page = 56; // Page of data. (optional) (default to 0)
Integer *pageSize = 56; // Size of the page. (optional) (default to 100)
Boolean *all = true; // If all data should be retrieved. If true, `page` and `pageSize` are ignored. (optional) (default to null)

// Retrieve popularity data for project
[apiInstance getSuggesterPopularityDataWith:project
    field:field
    page:page
    pageSize:pageSize
    all:all
              completionHandler: ^(array[map['String', 'Integer']] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');

// Create an instance of the API class
var api = new OpenGrokResTfulApi.SuggesterApi()
var project = project_example; // {String} Project name.
var opts = {
  'field': field_example, // {String} Field for which to retrieve data.
  'page': 56, // {Integer} Page of data.
  'pageSize': 56, // {Integer} Size of the page.
  'all': true // {Boolean} If all data should be retrieved. If true, `page` and `pageSize` are ignored.
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new SuggesterApi();
            var project = project_example;  // String | Project name. (default to null)
            var field = field_example;  // String | Field for which to retrieve data. (optional)  (default to full)
            var page = 56;  // Integer | Page of data. (optional)  (default to 0)
            var pageSize = 56;  // Integer | Size of the page. (optional)  (default to 100)
            var all = true;  // Boolean | If all data should be retrieved. If true, `page` and `pageSize` are ignored. (optional)  (default to null)

            try {
                // Retrieve popularity data for project
                array[map['String', 'Integer']] result = apiInstance.getSuggesterPopularityData(project, field, page, pageSize, all);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SuggesterApi.getSuggesterPopularityData: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SuggesterApi();
$project = project_example; // String | Project name.
$field = field_example; // String | Field for which to retrieve data.
$page = 56; // Integer | Page of data.
$pageSize = 56; // Integer | Size of the page.
$all = true; // Boolean | If all data should be retrieved. If true, `page` and `pageSize` are ignored.

try {
    $result = $api_instance->getSuggesterPopularityData($project, $field, $page, $pageSize, $all);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SuggesterApi->getSuggesterPopularityData: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SuggesterApi->new();
my $project = project_example; # String | Project name.
my $field = field_example; # String | Field for which to retrieve data.
my $page = 56; # Integer | Page of data.
my $pageSize = 56; # Integer | Size of the page.
my $all = true; # Boolean | If all data should be retrieved. If true, `page` and `pageSize` are ignored.

eval {
    my $result = $api_instance->getSuggesterPopularityData(project => $project, field => $field, page => $page, pageSize => $pageSize, all => $all);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SuggesterApi->getSuggesterPopularityData: $@\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.SuggesterApi()
project = project_example # String | Project name. (default to null)
field = field_example # String | Field for which to retrieve data. (optional) (default to full)
page = 56 # Integer | Page of data. (optional) (default to 0)
pageSize = 56 # Integer | Size of the page. (optional) (default to 100)
all = true # Boolean | If all data should be retrieved. If true, `page` and `pageSize` are ignored. (optional) (default to null)

try:
    # Retrieve popularity data for project
    api_response = api_instance.get_suggester_popularity_data(project, field=field, page=page, pageSize=pageSize, all=all)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SuggesterApi->getSuggesterPopularityData: %s\n" % e)

extern crate SuggesterApi;

pub fn main() {
    let project = project_example; // String
    let field = field_example; // String
    let page = 56; // Integer
    let pageSize = 56; // Integer
    let all = true; // Boolean

    let mut context = SuggesterApi::Context::default();
    let result = client.getSuggesterPopularityData(project, field, page, pageSize, all, &context).wait();

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

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

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

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

        // Create an instance of the API class
        SuggesterApi apiInstance = new SuggesterApi();
        String projects = projects_example; // String | List of projects for which to retrieve suggestions.
        String field = field_example; // String | Field for which to suggest.
        Integer caret = 56; // Integer | Position of the caret in the input field.
        String full = full_example; // String | Value of the Full Search input.
        String defs = defs_example; // String | Value of the Definitions input.
        String refs = refs_example; // String | Value of Symbol input.
        String path = path_example; // String | Value of the File Path input.
        String hist = hist_example; // String | Value of the History input.
        String type = type_example; // String | Value of the Type input.

        try {
            SuggestResponse result = apiInstance.getSuggestions(projects, field, caret, full, defs, refs, path, hist, type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SuggesterApi#getSuggestions");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String projects = new String(); // String | List of projects for which to retrieve suggestions.
final String field = new String(); // String | Field for which to suggest.
final Integer caret = new Integer(); // Integer | Position of the caret in the input field.
final String full = new String(); // String | Value of the Full Search input.
final String defs = new String(); // String | Value of the Definitions input.
final String refs = new String(); // String | Value of Symbol input.
final String path = new String(); // String | Value of the File Path input.
final String hist = new String(); // String | Value of the History input.
final String type = new String(); // String | Value of the Type input.

try {
    final result = await api_instance.getSuggestions(projects, field, caret, full, defs, refs, path, hist, type);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getSuggestions: $e\n');
}

import org.openapitools.client.api.SuggesterApi;

public class SuggesterApiExample {
    public static void main(String[] args) {
        SuggesterApi apiInstance = new SuggesterApi();
        String projects = projects_example; // String | List of projects for which to retrieve suggestions.
        String field = field_example; // String | Field for which to suggest.
        Integer caret = 56; // Integer | Position of the caret in the input field.
        String full = full_example; // String | Value of the Full Search input.
        String defs = defs_example; // String | Value of the Definitions input.
        String refs = refs_example; // String | Value of Symbol input.
        String path = path_example; // String | Value of the File Path input.
        String hist = hist_example; // String | Value of the History input.
        String type = type_example; // String | Value of the Type input.

        try {
            SuggestResponse result = apiInstance.getSuggestions(projects, field, caret, full, defs, refs, path, hist, type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SuggesterApi#getSuggestions");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
SuggesterApi *apiInstance = [[SuggesterApi alloc] init];
String *projects = projects_example; // List of projects for which to retrieve suggestions. (default to null)
String *field = field_example; // Field for which to suggest. (default to null)
Integer *caret = 56; // Position of the caret in the input field. (default to null)
String *full = full_example; // Value of the Full Search input. (optional) (default to null)
String *defs = defs_example; // Value of the Definitions input. (optional) (default to null)
String *refs = refs_example; // Value of Symbol input. (optional) (default to null)
String *path = path_example; // Value of the File Path input. (optional) (default to null)
String *hist = hist_example; // Value of the History input. (optional) (default to null)
String *type = type_example; // Value of the Type input. (optional) (default to null)

// Return suggestions
[apiInstance getSuggestionsWith:projects
    field:field
    caret:caret
    full:full
    defs:defs
    refs:refs
    path:path
    hist:hist
    type:type
              completionHandler: ^(SuggestResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');

// Create an instance of the API class
var api = new OpenGrokResTfulApi.SuggesterApi()
var projects = projects_example; // {String} List of projects for which to retrieve suggestions.
var field = field_example; // {String} Field for which to suggest.
var caret = 56; // {Integer} Position of the caret in the input field.
var opts = {
  'full': full_example, // {String} Value of the Full Search input.
  'defs': defs_example, // {String} Value of the Definitions input.
  'refs': refs_example, // {String} Value of Symbol input.
  'path': path_example, // {String} Value of the File Path input.
  'hist': hist_example, // {String} Value of the History input.
  'type': type_example // {String} Value of the Type input.
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new SuggesterApi();
            var projects = projects_example;  // String | List of projects for which to retrieve suggestions. (default to null)
            var field = field_example;  // String | Field for which to suggest. (default to null)
            var caret = 56;  // Integer | Position of the caret in the input field. (default to null)
            var full = full_example;  // String | Value of the Full Search input. (optional)  (default to null)
            var defs = defs_example;  // String | Value of the Definitions input. (optional)  (default to null)
            var refs = refs_example;  // String | Value of Symbol input. (optional)  (default to null)
            var path = path_example;  // String | Value of the File Path input. (optional)  (default to null)
            var hist = hist_example;  // String | Value of the History input. (optional)  (default to null)
            var type = type_example;  // String | Value of the Type input. (optional)  (default to null)

            try {
                // Return suggestions
                SuggestResponse result = apiInstance.getSuggestions(projects, field, caret, full, defs, refs, path, hist, type);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SuggesterApi.getSuggestions: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SuggesterApi();
$projects = projects_example; // String | List of projects for which to retrieve suggestions.
$field = field_example; // String | Field for which to suggest.
$caret = 56; // Integer | Position of the caret in the input field.
$full = full_example; // String | Value of the Full Search input.
$defs = defs_example; // String | Value of the Definitions input.
$refs = refs_example; // String | Value of Symbol input.
$path = path_example; // String | Value of the File Path input.
$hist = hist_example; // String | Value of the History input.
$type = type_example; // String | Value of the Type input.

try {
    $result = $api_instance->getSuggestions($projects, $field, $caret, $full, $defs, $refs, $path, $hist, $type);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SuggesterApi->getSuggestions: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SuggesterApi->new();
my $projects = projects_example; # String | List of projects for which to retrieve suggestions.
my $field = field_example; # String | Field for which to suggest.
my $caret = 56; # Integer | Position of the caret in the input field.
my $full = full_example; # String | Value of the Full Search input.
my $defs = defs_example; # String | Value of the Definitions input.
my $refs = refs_example; # String | Value of Symbol input.
my $path = path_example; # String | Value of the File Path input.
my $hist = hist_example; # String | Value of the History input.
my $type = type_example; # String | Value of the Type input.

eval {
    my $result = $api_instance->getSuggestions(projects => $projects, field => $field, caret => $caret, full => $full, defs => $defs, refs => $refs, path => $path, hist => $hist, type => $type);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SuggesterApi->getSuggestions: $@\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.SuggesterApi()
projects = projects_example # String | List of projects for which to retrieve suggestions. (default to null)
field = field_example # String | Field for which to suggest. (default to null)
caret = 56 # Integer | Position of the caret in the input field. (default to null)
full = full_example # String | Value of the Full Search input. (optional) (default to null)
defs = defs_example # String | Value of the Definitions input. (optional) (default to null)
refs = refs_example # String | Value of Symbol input. (optional) (default to null)
path = path_example # String | Value of the File Path input. (optional) (default to null)
hist = hist_example # String | Value of the History input. (optional) (default to null)
type = type_example # String | Value of the Type input. (optional) (default to null)

try:
    # Return suggestions
    api_response = api_instance.get_suggestions(projects, field, caret, full=full, defs=defs, refs=refs, path=path, hist=hist, type=type)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SuggesterApi->getSuggestions: %s\n" % e)

extern crate SuggesterApi;

pub fn main() {
    let projects = projects_example; // String
    let field = field_example; // String
    let caret = 56; // Integer
    let full = full_example; // String
    let defs = defs_example; // String
    let refs = refs_example; // String
    let path = path_example; // String
    let hist = hist_example; // String
    let type = type_example; // String

    let mut context = SuggesterApi::Context::default();
    let result = client.getSuggestions(projects, field, caret, full, defs, refs, path, hist, type, &context).wait();

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

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

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

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

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

        // Create an instance of the API class
        SuggesterApi apiInstance = new SuggesterApi();
        array[String] string = ["http://localhost:8080/source/search?project=kotlin&full=text"]; // array[String] | 

        try {
            apiInstance.initializeSuggesterPopularityFromQueries(string);
        } catch (ApiException e) {
            System.err.println("Exception when calling SuggesterApi#initializeSuggesterPopularityFromQueries");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[String] string = new array[String](); // array[String] | 

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

import org.openapitools.client.api.SuggesterApi;

public class SuggesterApiExample {
    public static void main(String[] args) {
        SuggesterApi apiInstance = new SuggesterApi();
        array[String] string = ["http://localhost:8080/source/search?project=kotlin&full=text"]; // array[String] | 

        try {
            apiInstance.initializeSuggesterPopularityFromQueries(string);
        } catch (ApiException e) {
            System.err.println("Exception when calling SuggesterApi#initializeSuggesterPopularityFromQueries");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SuggesterApi *apiInstance = [[SuggesterApi alloc] init];
array[String] *string = ["http://localhost:8080/source/search?project=kotlin&full=text"]; // 

// Update popularity data based on queries
[apiInstance initializeSuggesterPopularityFromQueriesWith:string
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');
var defaultClient = OpenGrokResTfulApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new OpenGrokResTfulApi.SuggesterApi()
var string = ["http://localhost:8080/source/search?project=kotlin&full=text"]; // {array[String]} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new SuggesterApi();
            var string = new array[String](); // array[String] | 

            try {
                // Update popularity data based on queries
                apiInstance.initializeSuggesterPopularityFromQueries(string);
            } catch (Exception e) {
                Debug.Print("Exception when calling SuggesterApi.initializeSuggesterPopularityFromQueries: " + e.Message );
            }
        }
    }
}

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SuggesterApi();
$string = ["http://localhost:8080/source/search?project=kotlin&full=text"]; // array[String] | 

try {
    $api_instance->initializeSuggesterPopularityFromQueries($string);
} catch (Exception $e) {
    echo 'Exception when calling SuggesterApi->initializeSuggesterPopularityFromQueries: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SuggesterApi->new();
my $string = [WWW::OPenAPIClient::Object::array[String]->new()]; # array[String] | 

eval {
    $api_instance->initializeSuggesterPopularityFromQueries(string => $string);
};
if ($@) {
    warn "Exception when calling SuggesterApi->initializeSuggesterPopularityFromQueries: $@\n";
}

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

# Configure Bearer (token) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.SuggesterApi()
string = ["http://localhost:8080/source/search?project=kotlin&full=text"] # array[String] | 

try:
    # Update popularity data based on queries
    api_instance.initialize_suggester_popularity_from_queries(string)
except ApiException as e:
    print("Exception when calling SuggesterApi->initializeSuggesterPopularityFromQueries: %s\n" % e)

extern crate SuggesterApi;

pub fn main() {
    let string = ["http://localhost:8080/source/search?project=kotlin&full=text"]; // array[String]

    let mut context = SuggesterApi::Context::default();
    let result = client.initializeSuggesterPopularityFromQueries(string, &context).wait();

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

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

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

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

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

        // Create an instance of the API class
        SuggesterApi apiInstance = new SuggesterApi();
        array[SuggesterRawPopularityData] suggesterRawPopularityData = [{"project":"kotlin","field":"full","token":"args","increment":100}]; // array[SuggesterRawPopularityData] | 

        try {
            apiInstance.initializeSuggesterPopularityFromRawData(suggesterRawPopularityData);
        } catch (ApiException e) {
            System.err.println("Exception when calling SuggesterApi#initializeSuggesterPopularityFromRawData");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[SuggesterRawPopularityData] suggesterRawPopularityData = new array[SuggesterRawPopularityData](); // array[SuggesterRawPopularityData] | 

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

import org.openapitools.client.api.SuggesterApi;

public class SuggesterApiExample {
    public static void main(String[] args) {
        SuggesterApi apiInstance = new SuggesterApi();
        array[SuggesterRawPopularityData] suggesterRawPopularityData = [{"project":"kotlin","field":"full","token":"args","increment":100}]; // array[SuggesterRawPopularityData] | 

        try {
            apiInstance.initializeSuggesterPopularityFromRawData(suggesterRawPopularityData);
        } catch (ApiException e) {
            System.err.println("Exception when calling SuggesterApi#initializeSuggesterPopularityFromRawData");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SuggesterApi *apiInstance = [[SuggesterApi alloc] init];
array[SuggesterRawPopularityData] *suggesterRawPopularityData = [{"project":"kotlin","field":"full","token":"args","increment":100}]; // 

// Update popularity data based on the provided data
[apiInstance initializeSuggesterPopularityFromRawDataWith:suggesterRawPopularityData
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');
var defaultClient = OpenGrokResTfulApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new OpenGrokResTfulApi.SuggesterApi()
var suggesterRawPopularityData = [{"project":"kotlin","field":"full","token":"args","increment":100}]; // {array[SuggesterRawPopularityData]} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new SuggesterApi();
            var suggesterRawPopularityData = new array[SuggesterRawPopularityData](); // array[SuggesterRawPopularityData] | 

            try {
                // Update popularity data based on the provided data
                apiInstance.initializeSuggesterPopularityFromRawData(suggesterRawPopularityData);
            } catch (Exception e) {
                Debug.Print("Exception when calling SuggesterApi.initializeSuggesterPopularityFromRawData: " + e.Message );
            }
        }
    }
}

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SuggesterApi();
$suggesterRawPopularityData = [{"project":"kotlin","field":"full","token":"args","increment":100}]; // array[SuggesterRawPopularityData] | 

try {
    $api_instance->initializeSuggesterPopularityFromRawData($suggesterRawPopularityData);
} catch (Exception $e) {
    echo 'Exception when calling SuggesterApi->initializeSuggesterPopularityFromRawData: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SuggesterApi->new();
my $suggesterRawPopularityData = [WWW::OPenAPIClient::Object::array[SuggesterRawPopularityData]->new()]; # array[SuggesterRawPopularityData] | 

eval {
    $api_instance->initializeSuggesterPopularityFromRawData(suggesterRawPopularityData => $suggesterRawPopularityData);
};
if ($@) {
    warn "Exception when calling SuggesterApi->initializeSuggesterPopularityFromRawData: $@\n";
}

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

# Configure Bearer (token) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.SuggesterApi()
suggesterRawPopularityData = [{"project":"kotlin","field":"full","token":"args","increment":100}] # array[SuggesterRawPopularityData] | 

try:
    # Update popularity data based on the provided data
    api_instance.initialize_suggester_popularity_from_raw_data(suggesterRawPopularityData)
except ApiException as e:
    print("Exception when calling SuggesterApi->initializeSuggesterPopularityFromRawData: %s\n" % e)

extern crate SuggesterApi;

pub fn main() {
    let suggesterRawPopularityData = [{"project":"kotlin","field":"full","token":"args","increment":100}]; // array[SuggesterRawPopularityData]

    let mut context = SuggesterApi::Context::default();
    let result = client.initializeSuggesterPopularityFromRawData(suggesterRawPopularityData, &context).wait();

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

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

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

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

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

        // Create an instance of the API class
        SuggesterApi apiInstance = new SuggesterApi();
        String project = project_example; // String | Project name.

        try {
            apiInstance.rebuildProjectSuggesterData(project);
        } catch (ApiException e) {
            System.err.println("Exception when calling SuggesterApi#rebuildProjectSuggesterData");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String project = new String(); // String | Project name.

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

import org.openapitools.client.api.SuggesterApi;

public class SuggesterApiExample {
    public static void main(String[] args) {
        SuggesterApi apiInstance = new SuggesterApi();
        String project = project_example; // String | Project name.

        try {
            apiInstance.rebuildProjectSuggesterData(project);
        } catch (ApiException e) {
            System.err.println("Exception when calling SuggesterApi#rebuildProjectSuggesterData");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SuggesterApi *apiInstance = [[SuggesterApi alloc] init];
String *project = project_example; // Project name. (default to null)

// Rebuild suggester data for given project
[apiInstance rebuildProjectSuggesterDataWith:project
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');
var defaultClient = OpenGrokResTfulApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new OpenGrokResTfulApi.SuggesterApi()
var project = project_example; // {String} Project name.

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

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

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

            // Create an instance of the API class
            var apiInstance = new SuggesterApi();
            var project = project_example;  // String | Project name. (default to null)

            try {
                // Rebuild suggester data for given project
                apiInstance.rebuildProjectSuggesterData(project);
            } catch (Exception e) {
                Debug.Print("Exception when calling SuggesterApi.rebuildProjectSuggesterData: " + e.Message );
            }
        }
    }
}

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SuggesterApi();
$project = project_example; // String | Project name.

try {
    $api_instance->rebuildProjectSuggesterData($project);
} catch (Exception $e) {
    echo 'Exception when calling SuggesterApi->rebuildProjectSuggesterData: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SuggesterApi->new();
my $project = project_example; # String | Project name.

eval {
    $api_instance->rebuildProjectSuggesterData(project => $project);
};
if ($@) {
    warn "Exception when calling SuggesterApi->rebuildProjectSuggesterData: $@\n";
}

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

# Configure Bearer (token) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.SuggesterApi()
project = project_example # String | Project name. (default to null)

try:
    # Rebuild suggester data for given project
    api_instance.rebuild_project_suggester_data(project)
except ApiException as e:
    print("Exception when calling SuggesterApi->rebuildProjectSuggesterData: %s\n" % e)

extern crate SuggesterApi;

pub fn main() {
    let project = project_example; // String

    let mut context = SuggesterApi::Context::default();
    let result = client.rebuildProjectSuggesterData(project, &context).wait();

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

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.SuggesterApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

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

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

// Rebuild suggester data for all projects
[apiInstance rebuildSuggesterDataWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');
var defaultClient = OpenGrokResTfulApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new OpenGrokResTfulApi.SuggesterApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.rebuildSuggesterData(callback);

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

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

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

            try {
                // Rebuild suggester data for all projects
                apiInstance.rebuildSuggesterData();
            } catch (Exception e) {
                Debug.Print("Exception when calling SuggesterApi.rebuildSuggesterData: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

eval {
    $api_instance->rebuildSuggesterData();
};
if ($@) {
    warn "Exception when calling SuggesterApi->rebuildSuggesterData: $@\n";
}

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

# Configure Bearer (token) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Rebuild suggester data for all projects
    api_instance.rebuild_suggester_data()
except ApiException as e:
    print("Exception when calling SuggesterApi->rebuildSuggesterData: %s\n" % e)

extern crate SuggesterApi;

pub fn main() {

    let mut context = SuggesterApi::Context::default();
    let result = client.rebuildSuggesterData(&context).wait();

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

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

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

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

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

        try {
            'Date' result = apiInstance.getLastIndexTime();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemApi#getLastIndexTime");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.SystemApi;

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

        try {
            'Date' result = apiInstance.getLastIndexTime();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemApi#getLastIndexTime");
            e.printStackTrace();
        }
    }
}

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

// Retrieve last index time
[apiInstance getLastIndexTimeWithCompletionHandler: 
              ^('Date' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');

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

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

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

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

            try {
                // Retrieve last index time
                'Date' result = apiInstance.getLastIndexTime();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SystemApi.getLastIndexTime: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->getLastIndexTime();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SystemApi->getLastIndexTime: $@\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.SystemApi()

try:
    # Retrieve last index time
    api_response = api_instance.get_last_index_time()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SystemApi->getLastIndexTime: %s\n" % e)

extern crate SystemApi;

pub fn main() {

    let mut context = SystemApi::Context::default();
    let result = client.getLastIndexTime(&context).wait();

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

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

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

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

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

        try {
            'String' result = apiInstance.getWebAppVersion();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemApi#getWebAppVersion");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.SystemApi;

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

        try {
            'String' result = apiInstance.getWebAppVersion();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemApi#getWebAppVersion");
            e.printStackTrace();
        }
    }
}

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

// Get web application version as string
[apiInstance getWebAppVersionWithCompletionHandler: 
              ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');

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

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

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

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

            try {
                // Get web application version as string
                'String' result = apiInstance.getWebAppVersion();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SystemApi.getWebAppVersion: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->getWebAppVersion();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SystemApi->getWebAppVersion: $@\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.SystemApi()

try:
    # Get web application version as string
    api_response = api_instance.get_web_app_version()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SystemApi->getWebAppVersion: %s\n" % e)

extern crate SystemApi;

pub fn main() {

    let mut context = SystemApi::Context::default();
    let result = client.getWebAppVersion(&context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.SystemApi;

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

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

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

// Check if web app is deployed and alive
[apiInstance pingWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');

// Create an instance of the API class
var api = new OpenGrokResTfulApi.SystemApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ping(callback);

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

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

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

            try {
                // Check if web app is deployed and alive
                apiInstance.ping();
            } catch (Exception e) {
                Debug.Print("Exception when calling SystemApi.ping: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    $api_instance->ping();
};
if ($@) {
    warn "Exception when calling SystemApi->ping: $@\n";
}

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

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

try:
    # Check if web app is deployed and alive
    api_instance.ping()
except ApiException as e:
    print("Exception when calling SystemApi->ping: %s\n" % e)

extern crate SystemApi;

pub fn main() {

    let mut context = SystemApi::Context::default();
    let result = client.ping(&context).wait();

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

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.SystemApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

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

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

// Reload all include files for web application
[apiInstance reloadIncludesWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');
var defaultClient = OpenGrokResTfulApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new OpenGrokResTfulApi.SystemApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.reloadIncludes(callback);

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

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

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

            try {
                // Reload all include files for web application
                apiInstance.reloadIncludes();
            } catch (Exception e) {
                Debug.Print("Exception when calling SystemApi.reloadIncludes: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

eval {
    $api_instance->reloadIncludes();
};
if ($@) {
    warn "Exception when calling SystemApi->reloadIncludes: $@\n";
}

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

# Configure Bearer (token) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Reload all include files for web application
    api_instance.reload_includes()
except ApiException as e:
    print("Exception when calling SystemApi->reloadIncludes: %s\n" % e)

extern crate SystemApi;

pub fn main() {

    let mut context = SystemApi::Context::default();
    let result = client.reloadIncludes(&context).wait();

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

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

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

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

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

        // Create an instance of the API class
        SystemApi apiInstance = new SystemApi();
        array[PathDescription] pathDescription = [{"path":"/foo","description":"foo foo"},{"path":"/bar","description":"bar"}]; // array[PathDescription] | 

        try {
            apiInstance.updatePathDescriptions(pathDescription);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemApi#updatePathDescriptions");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[PathDescription] pathDescription = new array[PathDescription](); // array[PathDescription] | 

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

import org.openapitools.client.api.SystemApi;

public class SystemApiExample {
    public static void main(String[] args) {
        SystemApi apiInstance = new SystemApi();
        array[PathDescription] pathDescription = [{"path":"/foo","description":"foo foo"},{"path":"/bar","description":"bar"}]; // array[PathDescription] | 

        try {
            apiInstance.updatePathDescriptions(pathDescription);
        } catch (ApiException e) {
            System.err.println("Exception when calling SystemApi#updatePathDescriptions");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SystemApi *apiInstance = [[SystemApi alloc] init];
array[PathDescription] *pathDescription = [{"path":"/foo","description":"foo foo"},{"path":"/bar","description":"bar"}]; // 

// Update path descriptions for web application
[apiInstance updatePathDescriptionsWith:pathDescription
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenGrokResTfulApi = require('open_grok_res_tful_api');
var defaultClient = OpenGrokResTfulApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new OpenGrokResTfulApi.SystemApi()
var pathDescription = [{"path":"/foo","description":"foo foo"},{"path":"/bar","description":"bar"}]; // {array[PathDescription]} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new SystemApi();
            var pathDescription = new array[PathDescription](); // array[PathDescription] | 

            try {
                // Update path descriptions for web application
                apiInstance.updatePathDescriptions(pathDescription);
            } catch (Exception e) {
                Debug.Print("Exception when calling SystemApi.updatePathDescriptions: " + e.Message );
            }
        }
    }
}

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SystemApi();
$pathDescription = [{"path":"/foo","description":"foo foo"},{"path":"/bar","description":"bar"}]; // array[PathDescription] | 

try {
    $api_instance->updatePathDescriptions($pathDescription);
} catch (Exception $e) {
    echo 'Exception when calling SystemApi->updatePathDescriptions: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SystemApi->new();
my $pathDescription = [WWW::OPenAPIClient::Object::array[PathDescription]->new()]; # array[PathDescription] | 

eval {
    $api_instance->updatePathDescriptions(pathDescription => $pathDescription);
};
if ($@) {
    warn "Exception when calling SystemApi->updatePathDescriptions: $@\n";
}

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

# Configure Bearer (token) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.SystemApi()
pathDescription = [{"path":"/foo","description":"foo foo"},{"path":"/bar","description":"bar"}] # array[PathDescription] | 

try:
    # Update path descriptions for web application
    api_instance.update_path_descriptions(pathDescription)
except ApiException as e:
    print("Exception when calling SystemApi->updatePathDescriptions: %s\n" % e)

extern crate SystemApi;

pub fn main() {
    let pathDescription = [{"path":"/foo","description":"foo foo"},{"path":"/bar","description":"bar"}]; // array[PathDescription]

    let mut context = SystemApi::Context::default();
    let result = client.updatePathDescriptions(pathDescription, &context).wait();

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