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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.AdminApi;

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

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

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

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

var LinkedDataApi = require('linked_data_api');

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

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

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

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

            try {
                apiInstance.clearCaches();
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminApi.clearCaches: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    $api_instance->clearCaches();
};
if ($@) {
    warn "Exception when calling AdminApi->clearCaches: $@\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.AdminApi()

try:
    api_instance.clear_caches()
except ApiException as e:
    print("Exception when calling AdminApi->clearCaches: %s\n" % e)

extern crate AdminApi;

pub fn main() {

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

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

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

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

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

        // Create an instance of the API class
        AuthorityApi apiInstance = new AuthorityApi();
        AssignmentCheckDto assignmentCheckDto = ; // AssignmentCheckDto | 

        try {
            assignmentCheckResponseDto result = apiInstance.authorityAssignmentCheck(assignmentCheckDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthorityApi#authorityAssignmentCheck");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final AssignmentCheckDto assignmentCheckDto = new AssignmentCheckDto(); // AssignmentCheckDto | 

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

import org.openapitools.client.api.AuthorityApi;

public class AuthorityApiExample {
    public static void main(String[] args) {
        AuthorityApi apiInstance = new AuthorityApi();
        AssignmentCheckDto assignmentCheckDto = ; // AssignmentCheckDto | 

        try {
            assignmentCheckResponseDto result = apiInstance.authorityAssignmentCheck(assignmentCheckDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthorityApi#authorityAssignmentCheck");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AuthorityApi *apiInstance = [[AuthorityApi alloc] init];
AssignmentCheckDto *assignmentCheckDto = ; //  (optional)

[apiInstance authorityAssignmentCheckWith:assignmentCheckDto
              completionHandler: ^(assignmentCheckResponseDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.AuthorityApi()
var opts = {
  'assignmentCheckDto':  // {AssignmentCheckDto} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new AuthorityApi();
            var assignmentCheckDto = new AssignmentCheckDto(); // AssignmentCheckDto |  (optional) 

            try {
                assignmentCheckResponseDto result = apiInstance.authorityAssignmentCheck(assignmentCheckDto);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthorityApi.authorityAssignmentCheck: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthorityApi();
$assignmentCheckDto = ; // AssignmentCheckDto | 

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

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

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

eval {
    my $result = $api_instance->authorityAssignmentCheck(assignmentCheckDto => $assignmentCheckDto);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthorityApi->authorityAssignmentCheck: $@\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.AuthorityApi()
assignmentCheckDto =  # AssignmentCheckDto |  (optional)

try:
    api_response = api_instance.authority_assignment_check(assignmentCheckDto=assignmentCheckDto)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthorityApi->authorityAssignmentCheck: %s\n" % e)

extern crate AuthorityApi;

pub fn main() {
    let assignmentCheckDto = ; // AssignmentCheckDto

    let mut context = AuthorityApi::Context::default();
    let result = client.authorityAssignmentCheck(assignmentCheckDto, &context).wait();

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

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

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

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

        // Create an instance of the API class
        BatchJobApi apiInstance = new BatchJobApi();
        String resourceType = resourceType_example; // String | The specified resource type to be re-indexed. Available options: HUB, WORK

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String resourceType = new String(); // String | The specified resource type to be re-indexed. Available options: HUB, WORK

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

import org.openapitools.client.api.BatchJobApi;

public class BatchJobApiExample {
    public static void main(String[] args) {
        BatchJobApi apiInstance = new BatchJobApi();
        String resourceType = resourceType_example; // String | The specified resource type to be re-indexed. Available options: HUB, WORK

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

// Create an instance of the API class
BatchJobApi *apiInstance = [[BatchJobApi alloc] init];
String *resourceType = resourceType_example; // The specified resource type to be re-indexed. Available options: HUB, WORK (optional) (default to null)

[apiInstance fullReindexWith:resourceType
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.BatchJobApi()
var opts = {
  'resourceType': resourceType_example // {String} The specified resource type to be re-indexed. Available options: HUB, WORK
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new BatchJobApi();
            var resourceType = resourceType_example;  // String | The specified resource type to be re-indexed. Available options: HUB, WORK (optional)  (default to null)

            try {
                'String' result = apiInstance.fullReindex(resourceType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BatchJobApi.fullReindex: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BatchJobApi();
$resourceType = resourceType_example; // String | The specified resource type to be re-indexed. Available options: HUB, WORK

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BatchJobApi->new();
my $resourceType = resourceType_example; # String | The specified resource type to be re-indexed. Available options: HUB, WORK

eval {
    my $result = $api_instance->fullReindex(resourceType => $resourceType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BatchJobApi->fullReindex: $@\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.BatchJobApi()
resourceType = resourceType_example # String | The specified resource type to be re-indexed. Available options: HUB, WORK (optional) (default to null)

try:
    api_response = api_instance.full_reindex(resourceType=resourceType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BatchJobApi->fullReindex: %s\n" % e)

extern crate BatchJobApi;

pub fn main() {
    let resourceType = resourceType_example; // String

    let mut context = BatchJobApi::Context::default();
    let result = client.fullReindex(resourceType, &context).wait();

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

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

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

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

        // Create an instance of the API class
        BatchJobApi apiInstance = new BatchJobApi();
        Long jobExecutionId = 789; // Long | The ID of the job execution

        try {
            batchJobStatusDto result = apiInstance.getBatchJobStatus(jobExecutionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BatchJobApi#getBatchJobStatus");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long jobExecutionId = new Long(); // Long | The ID of the job execution

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

import org.openapitools.client.api.BatchJobApi;

public class BatchJobApiExample {
    public static void main(String[] args) {
        BatchJobApi apiInstance = new BatchJobApi();
        Long jobExecutionId = 789; // Long | The ID of the job execution

        try {
            batchJobStatusDto result = apiInstance.getBatchJobStatus(jobExecutionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BatchJobApi#getBatchJobStatus");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
BatchJobApi *apiInstance = [[BatchJobApi alloc] init];
Long *jobExecutionId = 789; // The ID of the job execution (default to null)

[apiInstance getBatchJobStatusWith:jobExecutionId
              completionHandler: ^(batchJobStatusDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.BatchJobApi()
var jobExecutionId = 789; // {Long} The ID of the job execution

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

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

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

            // Create an instance of the API class
            var apiInstance = new BatchJobApi();
            var jobExecutionId = 789;  // Long | The ID of the job execution (default to null)

            try {
                batchJobStatusDto result = apiInstance.getBatchJobStatus(jobExecutionId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BatchJobApi.getBatchJobStatus: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BatchJobApi();
$jobExecutionId = 789; // Long | The ID of the job execution

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BatchJobApi->new();
my $jobExecutionId = 789; # Long | The ID of the job execution

eval {
    my $result = $api_instance->getBatchJobStatus(jobExecutionId => $jobExecutionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BatchJobApi->getBatchJobStatus: $@\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.BatchJobApi()
jobExecutionId = 789 # Long | The ID of the job execution (default to null)

try:
    api_response = api_instance.get_batch_job_status(jobExecutionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BatchJobApi->getBatchJobStatus: %s\n" % e)

extern crate BatchJobApi;

pub fn main() {
    let jobExecutionId = 789; // Long

    let mut context = BatchJobApi::Context::default();
    let result = client.getBatchJobStatus(jobExecutionId, &context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.BatchJobApi;

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

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

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

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

var LinkedDataApi = require('linked_data_api');

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

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

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

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

            try {
                'String' result = apiInstance.graphCleaning();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BatchJobApi.graphCleaning: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate BatchJobApi;

pub fn main() {

    let mut context = BatchJobApi::Context::default();
    let result = client.graphCleaning(&context).wait();

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

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

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

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

        // Create an instance of the API class
        BatchJobApi apiInstance = new BatchJobApi();
        String resourceType = resourceType_example; // String | The specified resource type to be re-indexed. Available options: HUB, WORK

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String resourceType = new String(); // String | The specified resource type to be re-indexed. Available options: HUB, WORK

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

import org.openapitools.client.api.BatchJobApi;

public class BatchJobApiExample {
    public static void main(String[] args) {
        BatchJobApi apiInstance = new BatchJobApi();
        String resourceType = resourceType_example; // String | The specified resource type to be re-indexed. Available options: HUB, WORK

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

// Create an instance of the API class
BatchJobApi *apiInstance = [[BatchJobApi alloc] init];
String *resourceType = resourceType_example; // The specified resource type to be re-indexed. Available options: HUB, WORK (optional) (default to null)

[apiInstance incrementalReindexWith:resourceType
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.BatchJobApi()
var opts = {
  'resourceType': resourceType_example // {String} The specified resource type to be re-indexed. Available options: HUB, WORK
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new BatchJobApi();
            var resourceType = resourceType_example;  // String | The specified resource type to be re-indexed. Available options: HUB, WORK (optional)  (default to null)

            try {
                'String' result = apiInstance.incrementalReindex(resourceType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BatchJobApi.incrementalReindex: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BatchJobApi();
$resourceType = resourceType_example; // String | The specified resource type to be re-indexed. Available options: HUB, WORK

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BatchJobApi->new();
my $resourceType = resourceType_example; # String | The specified resource type to be re-indexed. Available options: HUB, WORK

eval {
    my $result = $api_instance->incrementalReindex(resourceType => $resourceType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BatchJobApi->incrementalReindex: $@\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.BatchJobApi()
resourceType = resourceType_example # String | The specified resource type to be re-indexed. Available options: HUB, WORK (optional) (default to null)

try:
    api_response = api_instance.incremental_reindex(resourceType=resourceType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BatchJobApi->incrementalReindex: %s\n" % e)

extern crate BatchJobApi;

pub fn main() {
    let resourceType = resourceType_example; // String

    let mut context = BatchJobApi::Context::default();
    let result = client.incrementalReindex(resourceType, &context).wait();

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

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

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

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

        // Create an instance of the API class
        GraphApi apiInstance = new GraphApi();
        Long id = 789; // Long | Linked Data resource id

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | Linked Data resource id

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

import org.openapitools.client.api.GraphApi;

public class GraphApiExample {
    public static void main(String[] args) {
        GraphApi apiInstance = new GraphApi();
        Long id = 789; // Long | Linked Data resource id

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

// Create an instance of the API class
GraphApi *apiInstance = [[GraphApi alloc] init];
Long *id = 789; // Linked Data resource id (default to null)

[apiInstance getResourceGraphByIdWith:id
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.GraphApi()
var id = 789; // {Long} Linked Data resource id

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

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

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

            // Create an instance of the API class
            var apiInstance = new GraphApi();
            var id = 789;  // Long | Linked Data resource id (default to null)

            try {
                Object result = apiInstance.getResourceGraphById(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphApi.getResourceGraphById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphApi();
$id = 789; // Long | Linked Data resource id

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphApi->new();
my $id = 789; # Long | Linked Data resource id

eval {
    my $result = $api_instance->getResourceGraphById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphApi->getResourceGraphById: $@\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.GraphApi()
id = 789 # Long | Linked Data resource id (default to null)

try:
    api_response = api_instance.get_resource_graph_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphApi->getResourceGraphById: %s\n" % e)

extern crate GraphApi;

pub fn main() {
    let id = 789; // Long

    let mut context = GraphApi::Context::default();
    let result = client.getResourceGraphById(id, &context).wait();

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

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

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

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

        // Create an instance of the API class
        HubApi apiInstance = new HubApi();
        String hubUri = hubUri_example; // String | URI of a remote Hub resource

        try {
            resourceResponseDto result = apiInstance.getHubPreviewByUri(hubUri);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HubApi#getHubPreviewByUri");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String hubUri = new String(); // String | URI of a remote Hub resource

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

import org.openapitools.client.api.HubApi;

public class HubApiExample {
    public static void main(String[] args) {
        HubApi apiInstance = new HubApi();
        String hubUri = hubUri_example; // String | URI of a remote Hub resource

        try {
            resourceResponseDto result = apiInstance.getHubPreviewByUri(hubUri);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HubApi#getHubPreviewByUri");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
HubApi *apiInstance = [[HubApi alloc] init];
String *hubUri = hubUri_example; // URI of a remote Hub resource (default to null)

[apiInstance getHubPreviewByUriWith:hubUri
              completionHandler: ^(resourceResponseDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.HubApi()
var hubUri = hubUri_example; // {String} URI of a remote Hub resource

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

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

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

            // Create an instance of the API class
            var apiInstance = new HubApi();
            var hubUri = hubUri_example;  // String | URI of a remote Hub resource (default to null)

            try {
                resourceResponseDto result = apiInstance.getHubPreviewByUri(hubUri);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling HubApi.getHubPreviewByUri: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\HubApi();
$hubUri = hubUri_example; // String | URI of a remote Hub resource

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::HubApi->new();
my $hubUri = hubUri_example; # String | URI of a remote Hub resource

eval {
    my $result = $api_instance->getHubPreviewByUri(hubUri => $hubUri);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HubApi->getHubPreviewByUri: $@\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.HubApi()
hubUri = hubUri_example # String | URI of a remote Hub resource (default to null)

try:
    api_response = api_instance.get_hub_preview_by_uri(hubUri)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HubApi->getHubPreviewByUri: %s\n" % e)

extern crate HubApi;

pub fn main() {
    let hubUri = hubUri_example; // String

    let mut context = HubApi::Context::default();
    let result = client.getHubPreviewByUri(hubUri, &context).wait();

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

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

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

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

        // Create an instance of the API class
        HubApi apiInstance = new HubApi();
        String hubUri = hubUri_example; // String | URI of a remote Hub resource

        try {
            resourceResponseDto result = apiInstance.saveHubByUri(hubUri);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HubApi#saveHubByUri");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String hubUri = new String(); // String | URI of a remote Hub resource

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

import org.openapitools.client.api.HubApi;

public class HubApiExample {
    public static void main(String[] args) {
        HubApi apiInstance = new HubApi();
        String hubUri = hubUri_example; // String | URI of a remote Hub resource

        try {
            resourceResponseDto result = apiInstance.saveHubByUri(hubUri);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HubApi#saveHubByUri");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
HubApi *apiInstance = [[HubApi alloc] init];
String *hubUri = hubUri_example; // URI of a remote Hub resource (default to null)

[apiInstance saveHubByUriWith:hubUri
              completionHandler: ^(resourceResponseDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.HubApi()
var hubUri = hubUri_example; // {String} URI of a remote Hub resource

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

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

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

            // Create an instance of the API class
            var apiInstance = new HubApi();
            var hubUri = hubUri_example;  // String | URI of a remote Hub resource (default to null)

            try {
                resourceResponseDto result = apiInstance.saveHubByUri(hubUri);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling HubApi.saveHubByUri: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\HubApi();
$hubUri = hubUri_example; // String | URI of a remote Hub resource

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::HubApi->new();
my $hubUri = hubUri_example; # String | URI of a remote Hub resource

eval {
    my $result = $api_instance->saveHubByUri(hubUri => $hubUri);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HubApi->saveHubByUri: $@\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.HubApi()
hubUri = hubUri_example # String | URI of a remote Hub resource (default to null)

try:
    api_response = api_instance.save_hub_by_uri(hubUri)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HubApi->saveHubByUri: %s\n" % e)

extern crate HubApi;

pub fn main() {
    let hubUri = hubUri_example; // String

    let mut context = HubApi::Context::default();
    let result = client.saveHubByUri(hubUri, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ImportApi apiInstance = new ImportApi();
        String filterType = filterType_example; // String | URI for the type of resource to filter in matches from import contents
        File fileName = BINARY_DATA_HERE; // File | 

        try {
            importResponseDto result = apiInstance.importFile(filterType, fileName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ImportApi#importFile");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String filterType = new String(); // String | URI for the type of resource to filter in matches from import contents
final File fileName = new File(); // File | 

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

import org.openapitools.client.api.ImportApi;

public class ImportApiExample {
    public static void main(String[] args) {
        ImportApi apiInstance = new ImportApi();
        String filterType = filterType_example; // String | URI for the type of resource to filter in matches from import contents
        File fileName = BINARY_DATA_HERE; // File | 

        try {
            importResponseDto result = apiInstance.importFile(filterType, fileName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ImportApi#importFile");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ImportApi *apiInstance = [[ImportApi alloc] init];
String *filterType = filterType_example; // URI for the type of resource to filter in matches from import contents (default to null)
File *fileName = BINARY_DATA_HERE; //  (optional) (default to null)

[apiInstance importFileWith:filterType
    fileName:fileName
              completionHandler: ^(importResponseDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ImportApi()
var filterType = filterType_example; // {String} URI for the type of resource to filter in matches from import contents
var opts = {
  'fileName': BINARY_DATA_HERE // {File} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ImportApi();
            var filterType = filterType_example;  // String | URI for the type of resource to filter in matches from import contents (default to null)
            var fileName = BINARY_DATA_HERE;  // File |  (optional)  (default to null)

            try {
                importResponseDto result = apiInstance.importFile(filterType, fileName);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ImportApi.importFile: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ImportApi();
$filterType = filterType_example; // String | URI for the type of resource to filter in matches from import contents
$fileName = BINARY_DATA_HERE; // File | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ImportApi->new();
my $filterType = filterType_example; # String | URI for the type of resource to filter in matches from import contents
my $fileName = BINARY_DATA_HERE; # File | 

eval {
    my $result = $api_instance->importFile(filterType => $filterType, fileName => $fileName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ImportApi->importFile: $@\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.ImportApi()
filterType = filterType_example # String | URI for the type of resource to filter in matches from import contents (default to null)
fileName = BINARY_DATA_HERE # File |  (optional) (default to null)

try:
    api_response = api_instance.import_file(filterType, fileName=fileName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ImportApi->importFile: %s\n" % e)

extern crate ImportApi;

pub fn main() {
    let filterType = filterType_example; // String
    let fileName = BINARY_DATA_HERE; // File

    let mut context = ImportApi::Context::default();
    let result = client.importFile(filterType, fileName, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ImportApi apiInstance = new ImportApi();
        String url = url_example; // String | URL of a remote Instance resource
        String filterType = filterType_example; // String | URI for the type of resource to filter in matches from import contents
        String defaultWorkType = defaultWorkType_example; // String | URI for the default Work type to use when no further Work typing is available

        try {
            importResponseDto result = apiInstance.importUrl(url, filterType, defaultWorkType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ImportApi#importUrl");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String url = new String(); // String | URL of a remote Instance resource
final String filterType = new String(); // String | URI for the type of resource to filter in matches from import contents
final String defaultWorkType = new String(); // String | URI for the default Work type to use when no further Work typing is available

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

import org.openapitools.client.api.ImportApi;

public class ImportApiExample {
    public static void main(String[] args) {
        ImportApi apiInstance = new ImportApi();
        String url = url_example; // String | URL of a remote Instance resource
        String filterType = filterType_example; // String | URI for the type of resource to filter in matches from import contents
        String defaultWorkType = defaultWorkType_example; // String | URI for the default Work type to use when no further Work typing is available

        try {
            importResponseDto result = apiInstance.importUrl(url, filterType, defaultWorkType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ImportApi#importUrl");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ImportApi *apiInstance = [[ImportApi alloc] init];
String *url = url_example; // URL of a remote Instance resource (default to null)
String *filterType = filterType_example; // URI for the type of resource to filter in matches from import contents (default to null)
String *defaultWorkType = defaultWorkType_example; // URI for the default Work type to use when no further Work typing is available (default to null)

[apiInstance importUrlWith:url
    filterType:filterType
    defaultWorkType:defaultWorkType
              completionHandler: ^(importResponseDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ImportApi()
var url = url_example; // {String} URL of a remote Instance resource
var filterType = filterType_example; // {String} URI for the type of resource to filter in matches from import contents
var defaultWorkType = defaultWorkType_example; // {String} URI for the default Work type to use when no further Work typing is available

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

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

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

            // Create an instance of the API class
            var apiInstance = new ImportApi();
            var url = url_example;  // String | URL of a remote Instance resource (default to null)
            var filterType = filterType_example;  // String | URI for the type of resource to filter in matches from import contents (default to null)
            var defaultWorkType = defaultWorkType_example;  // String | URI for the default Work type to use when no further Work typing is available (default to null)

            try {
                importResponseDto result = apiInstance.importUrl(url, filterType, defaultWorkType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ImportApi.importUrl: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ImportApi();
$url = url_example; // String | URL of a remote Instance resource
$filterType = filterType_example; // String | URI for the type of resource to filter in matches from import contents
$defaultWorkType = defaultWorkType_example; // String | URI for the default Work type to use when no further Work typing is available

try {
    $result = $api_instance->importUrl($url, $filterType, $defaultWorkType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ImportApi->importUrl: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ImportApi->new();
my $url = url_example; # String | URL of a remote Instance resource
my $filterType = filterType_example; # String | URI for the type of resource to filter in matches from import contents
my $defaultWorkType = defaultWorkType_example; # String | URI for the default Work type to use when no further Work typing is available

eval {
    my $result = $api_instance->importUrl(url => $url, filterType => $filterType, defaultWorkType => $defaultWorkType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ImportApi->importUrl: $@\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.ImportApi()
url = url_example # String | URL of a remote Instance resource (default to null)
filterType = filterType_example # String | URI for the type of resource to filter in matches from import contents (default to null)
defaultWorkType = defaultWorkType_example # String | URI for the default Work type to use when no further Work typing is available (default to null)

try:
    api_response = api_instance.import_url(url, filterType, defaultWorkType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ImportApi->importUrl: %s\n" % e)

extern crate ImportApi;

pub fn main() {
    let url = url_example; // String
    let filterType = filterType_example; // String
    let defaultWorkType = defaultWorkType_example; // String

    let mut context = ImportApi::Context::default();
    let result = client.importUrl(url, filterType, defaultWorkType, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ProfileApi apiInstance = new ProfileApi();
        String resourceType = resourceType_example; // String | The type of resource for which preferred profile has to be deleted.

        try {
            apiInstance.deletePreferredProfile(resourceType);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#deletePreferredProfile");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String resourceType = new String(); // String | The type of resource for which preferred profile has to be deleted.

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

import org.openapitools.client.api.ProfileApi;

public class ProfileApiExample {
    public static void main(String[] args) {
        ProfileApi apiInstance = new ProfileApi();
        String resourceType = resourceType_example; // String | The type of resource for which preferred profile has to be deleted.

        try {
            apiInstance.deletePreferredProfile(resourceType);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#deletePreferredProfile");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ProfileApi *apiInstance = [[ProfileApi alloc] init];
String *resourceType = resourceType_example; // The type of resource for which preferred profile has to be deleted. (default to null)

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

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ProfileApi()
var resourceType = resourceType_example; // {String} The type of resource for which preferred profile has to be deleted.

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProfileApi();
            var resourceType = resourceType_example;  // String | The type of resource for which preferred profile has to be deleted. (default to null)

            try {
                apiInstance.deletePreferredProfile(resourceType);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProfileApi.deletePreferredProfile: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProfileApi();
$resourceType = resourceType_example; // String | The type of resource for which preferred profile has to be deleted.

try {
    $api_instance->deletePreferredProfile($resourceType);
} catch (Exception $e) {
    echo 'Exception when calling ProfileApi->deletePreferredProfile: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProfileApi->new();
my $resourceType = resourceType_example; # String | The type of resource for which preferred profile has to be deleted.

eval {
    $api_instance->deletePreferredProfile(resourceType => $resourceType);
};
if ($@) {
    warn "Exception when calling ProfileApi->deletePreferredProfile: $@\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.ProfileApi()
resourceType = resourceType_example # String | The type of resource for which preferred profile has to be deleted. (default to null)

try:
    api_instance.delete_preferred_profile(resourceType)
except ApiException as e:
    print("Exception when calling ProfileApi->deletePreferredProfile: %s\n" % e)

extern crate ProfileApi;

pub fn main() {
    let resourceType = resourceType_example; // String

    let mut context = ProfileApi::Context::default();
    let result = client.deletePreferredProfile(resourceType, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ProfileApi apiInstance = new ProfileApi();
        String resourceType = resourceType_example; // String | The type of resource for which preferred profile is requested. If not specified, profiles for all resource types will be returned

        try {
            array[profileMetadata] result = apiInstance.getPreferredProfileByResourceType(resourceType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#getPreferredProfileByResourceType");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String resourceType = new String(); // String | The type of resource for which preferred profile is requested. If not specified, profiles for all resource types will be returned

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

import org.openapitools.client.api.ProfileApi;

public class ProfileApiExample {
    public static void main(String[] args) {
        ProfileApi apiInstance = new ProfileApi();
        String resourceType = resourceType_example; // String | The type of resource for which preferred profile is requested. If not specified, profiles for all resource types will be returned

        try {
            array[profileMetadata] result = apiInstance.getPreferredProfileByResourceType(resourceType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#getPreferredProfileByResourceType");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ProfileApi *apiInstance = [[ProfileApi alloc] init];
String *resourceType = resourceType_example; // The type of resource for which preferred profile is requested. If not specified, profiles for all resource types will be returned (optional) (default to null)

[apiInstance getPreferredProfileByResourceTypeWith:resourceType
              completionHandler: ^(array[profileMetadata] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ProfileApi()
var opts = {
  'resourceType': resourceType_example // {String} The type of resource for which preferred profile is requested. If not specified, profiles for all resource types will be returned
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProfileApi();
            var resourceType = resourceType_example;  // String | The type of resource for which preferred profile is requested. If not specified, profiles for all resource types will be returned (optional)  (default to null)

            try {
                array[profileMetadata] result = apiInstance.getPreferredProfileByResourceType(resourceType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProfileApi.getPreferredProfileByResourceType: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProfileApi();
$resourceType = resourceType_example; // String | The type of resource for which preferred profile is requested. If not specified, profiles for all resource types will be returned

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProfileApi->new();
my $resourceType = resourceType_example; # String | The type of resource for which preferred profile is requested. If not specified, profiles for all resource types will be returned

eval {
    my $result = $api_instance->getPreferredProfileByResourceType(resourceType => $resourceType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProfileApi->getPreferredProfileByResourceType: $@\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.ProfileApi()
resourceType = resourceType_example # String | The type of resource for which preferred profile is requested. If not specified, profiles for all resource types will be returned (optional) (default to null)

try:
    api_response = api_instance.get_preferred_profile_by_resource_type(resourceType=resourceType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProfileApi->getPreferredProfileByResourceType: %s\n" % e)

extern crate ProfileApi;

pub fn main() {
    let resourceType = resourceType_example; // String

    let mut context = ProfileApi::Context::default();
    let result = client.getPreferredProfileByResourceType(resourceType, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ProfileApi apiInstance = new ProfileApi();
        Integer profileId = 56; // Integer | ID of the profile

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer profileId = new Integer(); // Integer | ID of the profile

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

import org.openapitools.client.api.ProfileApi;

public class ProfileApiExample {
    public static void main(String[] args) {
        ProfileApi apiInstance = new ProfileApi();
        Integer profileId = 56; // Integer | ID of the profile

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

// Create an instance of the API class
ProfileApi *apiInstance = [[ProfileApi alloc] init];
Integer *profileId = 56; // ID of the profile (default to null)

[apiInstance getProfileByIdWith:profileId
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ProfileApi()
var profileId = 56; // {Integer} ID of the profile

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProfileApi();
            var profileId = 56;  // Integer | ID of the profile (default to null)

            try {
                'String' result = apiInstance.getProfileById(profileId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProfileApi.getProfileById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProfileApi();
$profileId = 56; // Integer | ID of the profile

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProfileApi->new();
my $profileId = 56; # Integer | ID of the profile

eval {
    my $result = $api_instance->getProfileById(profileId => $profileId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProfileApi->getProfileById: $@\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.ProfileApi()
profileId = 56 # Integer | ID of the profile (default to null)

try:
    api_response = api_instance.get_profile_by_id(profileId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProfileApi->getProfileById: %s\n" % e)

extern crate ProfileApi;

pub fn main() {
    let profileId = 56; // Integer

    let mut context = ProfileApi::Context::default();
    let result = client.getProfileById(profileId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ProfileApi apiInstance = new ProfileApi();
        String resourceType = resourceType_example; // String | The type of resource for which metadata are requested

        try {
            array[profileMetadata] result = apiInstance.getProfileMetadataByResourceType(resourceType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#getProfileMetadataByResourceType");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String resourceType = new String(); // String | The type of resource for which metadata are requested

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

import org.openapitools.client.api.ProfileApi;

public class ProfileApiExample {
    public static void main(String[] args) {
        ProfileApi apiInstance = new ProfileApi();
        String resourceType = resourceType_example; // String | The type of resource for which metadata are requested

        try {
            array[profileMetadata] result = apiInstance.getProfileMetadataByResourceType(resourceType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#getProfileMetadataByResourceType");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ProfileApi *apiInstance = [[ProfileApi alloc] init];
String *resourceType = resourceType_example; // The type of resource for which metadata are requested (default to null)

[apiInstance getProfileMetadataByResourceTypeWith:resourceType
              completionHandler: ^(array[profileMetadata] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ProfileApi()
var resourceType = resourceType_example; // {String} The type of resource for which metadata are requested

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProfileApi();
            var resourceType = resourceType_example;  // String | The type of resource for which metadata are requested (default to null)

            try {
                array[profileMetadata] result = apiInstance.getProfileMetadataByResourceType(resourceType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProfileApi.getProfileMetadataByResourceType: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProfileApi();
$resourceType = resourceType_example; // String | The type of resource for which metadata are requested

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProfileApi->new();
my $resourceType = resourceType_example; # String | The type of resource for which metadata are requested

eval {
    my $result = $api_instance->getProfileMetadataByResourceType(resourceType => $resourceType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProfileApi->getProfileMetadataByResourceType: $@\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.ProfileApi()
resourceType = resourceType_example # String | The type of resource for which metadata are requested (default to null)

try:
    api_response = api_instance.get_profile_metadata_by_resource_type(resourceType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProfileApi->getProfileMetadataByResourceType: %s\n" % e)

extern crate ProfileApi;

pub fn main() {
    let resourceType = resourceType_example; // String

    let mut context = ProfileApi::Context::default();
    let result = client.getProfileMetadataByResourceType(resourceType, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ProfileApi apiInstance = new ProfileApi();
        Integer profileId = 56; // Integer | ID of the profile

        try {
            customProfileSettingsResponseDto result = apiInstance.getProfileSettings(profileId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#getProfileSettings");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer profileId = new Integer(); // Integer | ID of the profile

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

import org.openapitools.client.api.ProfileApi;

public class ProfileApiExample {
    public static void main(String[] args) {
        ProfileApi apiInstance = new ProfileApi();
        Integer profileId = 56; // Integer | ID of the profile

        try {
            customProfileSettingsResponseDto result = apiInstance.getProfileSettings(profileId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#getProfileSettings");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ProfileApi *apiInstance = [[ProfileApi alloc] init];
Integer *profileId = 56; // ID of the profile (default to null)

[apiInstance getProfileSettingsWith:profileId
              completionHandler: ^(customProfileSettingsResponseDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ProfileApi()
var profileId = 56; // {Integer} ID of the profile

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProfileApi();
            var profileId = 56;  // Integer | ID of the profile (default to null)

            try {
                customProfileSettingsResponseDto result = apiInstance.getProfileSettings(profileId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProfileApi.getProfileSettings: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProfileApi();
$profileId = 56; // Integer | ID of the profile

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProfileApi->new();
my $profileId = 56; # Integer | ID of the profile

eval {
    my $result = $api_instance->getProfileSettings(profileId => $profileId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProfileApi->getProfileSettings: $@\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.ProfileApi()
profileId = 56 # Integer | ID of the profile (default to null)

try:
    api_response = api_instance.get_profile_settings(profileId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProfileApi->getProfileSettings: %s\n" % e)

extern crate ProfileApi;

pub fn main() {
    let profileId = 56; // Integer

    let mut context = ProfileApi::Context::default();
    let result = client.getProfileSettings(profileId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ProfileApi apiInstance = new ProfileApi();
        PreferredProfileRequest preferredProfileRequest = ; // PreferredProfileRequest | 

        try {
            apiInstance.setPreferredProfile(preferredProfileRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#setPreferredProfile");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final PreferredProfileRequest preferredProfileRequest = new PreferredProfileRequest(); // PreferredProfileRequest | 

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

import org.openapitools.client.api.ProfileApi;

public class ProfileApiExample {
    public static void main(String[] args) {
        ProfileApi apiInstance = new ProfileApi();
        PreferredProfileRequest preferredProfileRequest = ; // PreferredProfileRequest | 

        try {
            apiInstance.setPreferredProfile(preferredProfileRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#setPreferredProfile");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ProfileApi *apiInstance = [[ProfileApi alloc] init];
PreferredProfileRequest *preferredProfileRequest = ; //  (optional)

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

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ProfileApi()
var opts = {
  'preferredProfileRequest':  // {PreferredProfileRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProfileApi();
            var preferredProfileRequest = new PreferredProfileRequest(); // PreferredProfileRequest |  (optional) 

            try {
                apiInstance.setPreferredProfile(preferredProfileRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProfileApi.setPreferredProfile: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProfileApi();
$preferredProfileRequest = ; // PreferredProfileRequest | 

try {
    $api_instance->setPreferredProfile($preferredProfileRequest);
} catch (Exception $e) {
    echo 'Exception when calling ProfileApi->setPreferredProfile: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

eval {
    $api_instance->setPreferredProfile(preferredProfileRequest => $preferredProfileRequest);
};
if ($@) {
    warn "Exception when calling ProfileApi->setPreferredProfile: $@\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.ProfileApi()
preferredProfileRequest =  # PreferredProfileRequest |  (optional)

try:
    api_instance.set_preferred_profile(preferredProfileRequest=preferredProfileRequest)
except ApiException as e:
    print("Exception when calling ProfileApi->setPreferredProfile: %s\n" % e)

extern crate ProfileApi;

pub fn main() {
    let preferredProfileRequest = ; // PreferredProfileRequest

    let mut context = ProfileApi::Context::default();
    let result = client.setPreferredProfile(preferredProfileRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ProfileApi apiInstance = new ProfileApi();
        Integer profileId = 56; // Integer | ID of the profile
        CustomProfileSettingsRequestDto customProfileSettingsRequestDto = ; // CustomProfileSettingsRequestDto | 

        try {
            apiInstance.setProfileSettings(profileId, customProfileSettingsRequestDto);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#setProfileSettings");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer profileId = new Integer(); // Integer | ID of the profile
final CustomProfileSettingsRequestDto customProfileSettingsRequestDto = new CustomProfileSettingsRequestDto(); // CustomProfileSettingsRequestDto | 

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

import org.openapitools.client.api.ProfileApi;

public class ProfileApiExample {
    public static void main(String[] args) {
        ProfileApi apiInstance = new ProfileApi();
        Integer profileId = 56; // Integer | ID of the profile
        CustomProfileSettingsRequestDto customProfileSettingsRequestDto = ; // CustomProfileSettingsRequestDto | 

        try {
            apiInstance.setProfileSettings(profileId, customProfileSettingsRequestDto);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#setProfileSettings");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ProfileApi *apiInstance = [[ProfileApi alloc] init];
Integer *profileId = 56; // ID of the profile (default to null)
CustomProfileSettingsRequestDto *customProfileSettingsRequestDto = ; //  (optional)

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

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ProfileApi()
var profileId = 56; // {Integer} ID of the profile
var opts = {
  'customProfileSettingsRequestDto':  // {CustomProfileSettingsRequestDto} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProfileApi();
            var profileId = 56;  // Integer | ID of the profile (default to null)
            var customProfileSettingsRequestDto = new CustomProfileSettingsRequestDto(); // CustomProfileSettingsRequestDto |  (optional) 

            try {
                apiInstance.setProfileSettings(profileId, customProfileSettingsRequestDto);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProfileApi.setProfileSettings: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProfileApi();
$profileId = 56; // Integer | ID of the profile
$customProfileSettingsRequestDto = ; // CustomProfileSettingsRequestDto | 

try {
    $api_instance->setProfileSettings($profileId, $customProfileSettingsRequestDto);
} catch (Exception $e) {
    echo 'Exception when calling ProfileApi->setProfileSettings: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProfileApi->new();
my $profileId = 56; # Integer | ID of the profile
my $customProfileSettingsRequestDto = WWW::OPenAPIClient::Object::CustomProfileSettingsRequestDto->new(); # CustomProfileSettingsRequestDto | 

eval {
    $api_instance->setProfileSettings(profileId => $profileId, customProfileSettingsRequestDto => $customProfileSettingsRequestDto);
};
if ($@) {
    warn "Exception when calling ProfileApi->setProfileSettings: $@\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.ProfileApi()
profileId = 56 # Integer | ID of the profile (default to null)
customProfileSettingsRequestDto =  # CustomProfileSettingsRequestDto |  (optional)

try:
    api_instance.set_profile_settings(profileId, customProfileSettingsRequestDto=customProfileSettingsRequestDto)
except ApiException as e:
    print("Exception when calling ProfileApi->setProfileSettings: %s\n" % e)

extern crate ProfileApi;

pub fn main() {
    let profileId = 56; // Integer
    let customProfileSettingsRequestDto = ; // CustomProfileSettingsRequestDto

    let mut context = ProfileApi::Context::default();
    let result = client.setProfileSettings(profileId, customProfileSettingsRequestDto, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ResourceApi apiInstance = new ResourceApi();
        String inventoryId = inventoryId_example; // String | Inventory ID (999 $i) of the MARC record in SRS

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inventoryId = new String(); // String | Inventory ID (999 $i) of the MARC record in SRS

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

import org.openapitools.client.api.ResourceApi;

public class ResourceApiExample {
    public static void main(String[] args) {
        ResourceApi apiInstance = new ResourceApi();
        String inventoryId = inventoryId_example; // String | Inventory ID (999 $i) of the MARC record in SRS

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

// Create an instance of the API class
ResourceApi *apiInstance = [[ResourceApi alloc] init];
String *inventoryId = inventoryId_example; // Inventory ID (999 $i) of the MARC record in SRS (default to null)

[apiInstance checkMarcBibImportableToGraphWith:inventoryId
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ResourceApi()
var inventoryId = inventoryId_example; // {String} Inventory ID (999 $i) of the MARC record in SRS

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

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

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

            // Create an instance of the API class
            var apiInstance = new ResourceApi();
            var inventoryId = inventoryId_example;  // String | Inventory ID (999 $i) of the MARC record in SRS (default to null)

            try {
                'String' result = apiInstance.checkMarcBibImportableToGraph(inventoryId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ResourceApi.checkMarcBibImportableToGraph: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ResourceApi();
$inventoryId = inventoryId_example; // String | Inventory ID (999 $i) of the MARC record in SRS

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ResourceApi->new();
my $inventoryId = inventoryId_example; # String | Inventory ID (999 $i) of the MARC record in SRS

eval {
    my $result = $api_instance->checkMarcBibImportableToGraph(inventoryId => $inventoryId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ResourceApi->checkMarcBibImportableToGraph: $@\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.ResourceApi()
inventoryId = inventoryId_example # String | Inventory ID (999 $i) of the MARC record in SRS (default to null)

try:
    api_response = api_instance.check_marc_bib_importable_to_graph(inventoryId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ResourceApi->checkMarcBibImportableToGraph: %s\n" % e)

extern crate ResourceApi;

pub fn main() {
    let inventoryId = inventoryId_example; // String

    let mut context = ResourceApi::Context::default();
    let result = client.checkMarcBibImportableToGraph(inventoryId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ResourceApi apiInstance = new ResourceApi();
        ResourceRequestDto resourceRequestDto = ; // ResourceRequestDto | 

        try {
            resourceResponseDto result = apiInstance.createResource(resourceRequestDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#createResource");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ResourceRequestDto resourceRequestDto = new ResourceRequestDto(); // ResourceRequestDto | 

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

import org.openapitools.client.api.ResourceApi;

public class ResourceApiExample {
    public static void main(String[] args) {
        ResourceApi apiInstance = new ResourceApi();
        ResourceRequestDto resourceRequestDto = ; // ResourceRequestDto | 

        try {
            resourceResponseDto result = apiInstance.createResource(resourceRequestDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#createResource");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ResourceApi *apiInstance = [[ResourceApi alloc] init];
ResourceRequestDto *resourceRequestDto = ; //  (optional)

[apiInstance createResourceWith:resourceRequestDto
              completionHandler: ^(resourceResponseDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ResourceApi()
var opts = {
  'resourceRequestDto':  // {ResourceRequestDto} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ResourceApi();
            var resourceRequestDto = new ResourceRequestDto(); // ResourceRequestDto |  (optional) 

            try {
                resourceResponseDto result = apiInstance.createResource(resourceRequestDto);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ResourceApi.createResource: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ResourceApi();
$resourceRequestDto = ; // ResourceRequestDto | 

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

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

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

eval {
    my $result = $api_instance->createResource(resourceRequestDto => $resourceRequestDto);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ResourceApi->createResource: $@\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.ResourceApi()
resourceRequestDto =  # ResourceRequestDto |  (optional)

try:
    api_response = api_instance.create_resource(resourceRequestDto=resourceRequestDto)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ResourceApi->createResource: %s\n" % e)

extern crate ResourceApi;

pub fn main() {
    let resourceRequestDto = ; // ResourceRequestDto

    let mut context = ResourceApi::Context::default();
    let result = client.createResource(resourceRequestDto, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ResourceApi apiInstance = new ResourceApi();
        Long id = 789; // Long | Linked Data resource id

        try {
            apiInstance.deleteResource(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#deleteResource");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | Linked Data resource id

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

import org.openapitools.client.api.ResourceApi;

public class ResourceApiExample {
    public static void main(String[] args) {
        ResourceApi apiInstance = new ResourceApi();
        Long id = 789; // Long | Linked Data resource id

        try {
            apiInstance.deleteResource(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#deleteResource");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ResourceApi *apiInstance = [[ResourceApi alloc] init];
Long *id = 789; // Linked Data resource id (default to null)

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

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ResourceApi()
var id = 789; // {Long} Linked Data resource id

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

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

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

            // Create an instance of the API class
            var apiInstance = new ResourceApi();
            var id = 789;  // Long | Linked Data resource id (default to null)

            try {
                apiInstance.deleteResource(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling ResourceApi.deleteResource: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ResourceApi();
$id = 789; // Long | Linked Data resource id

try {
    $api_instance->deleteResource($id);
} catch (Exception $e) {
    echo 'Exception when calling ResourceApi->deleteResource: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ResourceApi->new();
my $id = 789; # Long | Linked Data resource id

eval {
    $api_instance->deleteResource(id => $id);
};
if ($@) {
    warn "Exception when calling ResourceApi->deleteResource: $@\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.ResourceApi()
id = 789 # Long | Linked Data resource id (default to null)

try:
    api_instance.delete_resource(id)
except ApiException as e:
    print("Exception when calling ResourceApi->deleteResource: %s\n" % e)

extern crate ResourceApi;

pub fn main() {
    let id = 789; // Long

    let mut context = ResourceApi::Context::default();
    let result = client.deleteResource(id, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ResourceApi apiInstance = new ResourceApi();
        Long id = 789; // Long | Linked Data resource id

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | Linked Data resource id

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

import org.openapitools.client.api.ResourceApi;

public class ResourceApiExample {
    public static void main(String[] args) {
        ResourceApi apiInstance = new ResourceApi();
        Long id = 789; // Long | Linked Data resource id

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

// Create an instance of the API class
ResourceApi *apiInstance = [[ResourceApi alloc] init];
Long *id = 789; // Linked Data resource id (default to null)

[apiInstance exportInstanceToRdfWith:id
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ResourceApi()
var id = 789; // {Long} Linked Data resource id

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

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

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

            // Create an instance of the API class
            var apiInstance = new ResourceApi();
            var id = 789;  // Long | Linked Data resource id (default to null)

            try {
                'String' result = apiInstance.exportInstanceToRdf(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ResourceApi.exportInstanceToRdf: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ResourceApi();
$id = 789; // Long | Linked Data resource id

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ResourceApi->new();
my $id = 789; # Long | Linked Data resource id

eval {
    my $result = $api_instance->exportInstanceToRdf(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ResourceApi->exportInstanceToRdf: $@\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.ResourceApi()
id = 789 # Long | Linked Data resource id (default to null)

try:
    api_response = api_instance.export_instance_to_rdf(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ResourceApi->exportInstanceToRdf: %s\n" % e)

extern crate ResourceApi;

pub fn main() {
    let id = 789; // Long

    let mut context = ResourceApi::Context::default();
    let result = client.exportInstanceToRdf(id, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ResourceApi apiInstance = new ResourceApi();
        Long id = 789; // Long | Linked Data resource id

        try {
            resourceResponseDto result = apiInstance.getResourceById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#getResourceById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | Linked Data resource id

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

import org.openapitools.client.api.ResourceApi;

public class ResourceApiExample {
    public static void main(String[] args) {
        ResourceApi apiInstance = new ResourceApi();
        Long id = 789; // Long | Linked Data resource id

        try {
            resourceResponseDto result = apiInstance.getResourceById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#getResourceById");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ResourceApi *apiInstance = [[ResourceApi alloc] init];
Long *id = 789; // Linked Data resource id (default to null)

[apiInstance getResourceByIdWith:id
              completionHandler: ^(resourceResponseDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ResourceApi()
var id = 789; // {Long} Linked Data resource id

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

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

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

            // Create an instance of the API class
            var apiInstance = new ResourceApi();
            var id = 789;  // Long | Linked Data resource id (default to null)

            try {
                resourceResponseDto result = apiInstance.getResourceById(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ResourceApi.getResourceById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ResourceApi();
$id = 789; // Long | Linked Data resource id

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ResourceApi->new();
my $id = 789; # Long | Linked Data resource id

eval {
    my $result = $api_instance->getResourceById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ResourceApi->getResourceById: $@\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.ResourceApi()
id = 789 # Long | Linked Data resource id (default to null)

try:
    api_response = api_instance.get_resource_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ResourceApi->getResourceById: %s\n" % e)

extern crate ResourceApi;

pub fn main() {
    let id = 789; // Long

    let mut context = ResourceApi::Context::default();
    let result = client.getResourceById(id, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ResourceApi apiInstance = new ResourceApi();
        String inventoryId = inventoryId_example; // String | Inventory ID (999 $i) of the MARC record in SRS

        try {
            resourceIdDto result = apiInstance.getResourceIdByResourceInventoryId(inventoryId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#getResourceIdByResourceInventoryId");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inventoryId = new String(); // String | Inventory ID (999 $i) of the MARC record in SRS

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

import org.openapitools.client.api.ResourceApi;

public class ResourceApiExample {
    public static void main(String[] args) {
        ResourceApi apiInstance = new ResourceApi();
        String inventoryId = inventoryId_example; // String | Inventory ID (999 $i) of the MARC record in SRS

        try {
            resourceIdDto result = apiInstance.getResourceIdByResourceInventoryId(inventoryId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#getResourceIdByResourceInventoryId");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ResourceApi *apiInstance = [[ResourceApi alloc] init];
String *inventoryId = inventoryId_example; // Inventory ID (999 $i) of the MARC record in SRS (default to null)

[apiInstance getResourceIdByResourceInventoryIdWith:inventoryId
              completionHandler: ^(resourceIdDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ResourceApi()
var inventoryId = inventoryId_example; // {String} Inventory ID (999 $i) of the MARC record in SRS

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

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

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

            // Create an instance of the API class
            var apiInstance = new ResourceApi();
            var inventoryId = inventoryId_example;  // String | Inventory ID (999 $i) of the MARC record in SRS (default to null)

            try {
                resourceIdDto result = apiInstance.getResourceIdByResourceInventoryId(inventoryId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ResourceApi.getResourceIdByResourceInventoryId: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ResourceApi();
$inventoryId = inventoryId_example; // String | Inventory ID (999 $i) of the MARC record in SRS

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ResourceApi->new();
my $inventoryId = inventoryId_example; # String | Inventory ID (999 $i) of the MARC record in SRS

eval {
    my $result = $api_instance->getResourceIdByResourceInventoryId(inventoryId => $inventoryId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ResourceApi->getResourceIdByResourceInventoryId: $@\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.ResourceApi()
inventoryId = inventoryId_example # String | Inventory ID (999 $i) of the MARC record in SRS (default to null)

try:
    api_response = api_instance.get_resource_id_by_resource_inventory_id(inventoryId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ResourceApi->getResourceIdByResourceInventoryId: %s\n" % e)

extern crate ResourceApi;

pub fn main() {
    let inventoryId = inventoryId_example; // String

    let mut context = ResourceApi::Context::default();
    let result = client.getResourceIdByResourceInventoryId(inventoryId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ResourceApi apiInstance = new ResourceApi();
        Long id = 789; // Long | Linked Data resource id

        try {
            resourceMarcViewDto result = apiInstance.getResourceMarcViewById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#getResourceMarcViewById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | Linked Data resource id

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

import org.openapitools.client.api.ResourceApi;

public class ResourceApiExample {
    public static void main(String[] args) {
        ResourceApi apiInstance = new ResourceApi();
        Long id = 789; // Long | Linked Data resource id

        try {
            resourceMarcViewDto result = apiInstance.getResourceMarcViewById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#getResourceMarcViewById");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ResourceApi *apiInstance = [[ResourceApi alloc] init];
Long *id = 789; // Linked Data resource id (default to null)

[apiInstance getResourceMarcViewByIdWith:id
              completionHandler: ^(resourceMarcViewDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ResourceApi()
var id = 789; // {Long} Linked Data resource id

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

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

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

            // Create an instance of the API class
            var apiInstance = new ResourceApi();
            var id = 789;  // Long | Linked Data resource id (default to null)

            try {
                resourceMarcViewDto result = apiInstance.getResourceMarcViewById(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ResourceApi.getResourceMarcViewById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ResourceApi();
$id = 789; // Long | Linked Data resource id

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ResourceApi->new();
my $id = 789; # Long | Linked Data resource id

eval {
    my $result = $api_instance->getResourceMarcViewById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ResourceApi->getResourceMarcViewById: $@\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.ResourceApi()
id = 789 # Long | Linked Data resource id (default to null)

try:
    api_response = api_instance.get_resource_marc_view_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ResourceApi->getResourceMarcViewById: %s\n" % e)

extern crate ResourceApi;

pub fn main() {
    let id = 789; // Long

    let mut context = ResourceApi::Context::default();
    let result = client.getResourceMarcViewById(id, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ResourceApi apiInstance = new ResourceApi();
        String inventoryId = inventoryId_example; // String | Inventory ID (999 $i) of the MARC record in SRS

        try {
            resourceResponseDto result = apiInstance.getResourcePreviewByInventoryId(inventoryId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#getResourcePreviewByInventoryId");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inventoryId = new String(); // String | Inventory ID (999 $i) of the MARC record in SRS

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

import org.openapitools.client.api.ResourceApi;

public class ResourceApiExample {
    public static void main(String[] args) {
        ResourceApi apiInstance = new ResourceApi();
        String inventoryId = inventoryId_example; // String | Inventory ID (999 $i) of the MARC record in SRS

        try {
            resourceResponseDto result = apiInstance.getResourcePreviewByInventoryId(inventoryId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#getResourcePreviewByInventoryId");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ResourceApi *apiInstance = [[ResourceApi alloc] init];
String *inventoryId = inventoryId_example; // Inventory ID (999 $i) of the MARC record in SRS (default to null)

[apiInstance getResourcePreviewByInventoryIdWith:inventoryId
              completionHandler: ^(resourceResponseDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ResourceApi()
var inventoryId = inventoryId_example; // {String} Inventory ID (999 $i) of the MARC record in SRS

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

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

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

            // Create an instance of the API class
            var apiInstance = new ResourceApi();
            var inventoryId = inventoryId_example;  // String | Inventory ID (999 $i) of the MARC record in SRS (default to null)

            try {
                resourceResponseDto result = apiInstance.getResourcePreviewByInventoryId(inventoryId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ResourceApi.getResourcePreviewByInventoryId: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ResourceApi();
$inventoryId = inventoryId_example; // String | Inventory ID (999 $i) of the MARC record in SRS

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ResourceApi->new();
my $inventoryId = inventoryId_example; # String | Inventory ID (999 $i) of the MARC record in SRS

eval {
    my $result = $api_instance->getResourcePreviewByInventoryId(inventoryId => $inventoryId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ResourceApi->getResourcePreviewByInventoryId: $@\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.ResourceApi()
inventoryId = inventoryId_example # String | Inventory ID (999 $i) of the MARC record in SRS (default to null)

try:
    api_response = api_instance.get_resource_preview_by_inventory_id(inventoryId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ResourceApi->getResourcePreviewByInventoryId: %s\n" % e)

extern crate ResourceApi;

pub fn main() {
    let inventoryId = inventoryId_example; // String

    let mut context = ResourceApi::Context::default();
    let result = client.getResourcePreviewByInventoryId(inventoryId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ResourceApi apiInstance = new ResourceApi();
        String inventoryId = inventoryId_example; // String | Inventory ID (999 $i) of the MARC record in SRS
        Integer profileId = 56; // Integer | ID of the profile

        try {
            resourceIdDto result = apiInstance.importMarcRecord(inventoryId, profileId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#importMarcRecord");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inventoryId = new String(); // String | Inventory ID (999 $i) of the MARC record in SRS
final Integer profileId = new Integer(); // Integer | ID of the profile

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

import org.openapitools.client.api.ResourceApi;

public class ResourceApiExample {
    public static void main(String[] args) {
        ResourceApi apiInstance = new ResourceApi();
        String inventoryId = inventoryId_example; // String | Inventory ID (999 $i) of the MARC record in SRS
        Integer profileId = 56; // Integer | ID of the profile

        try {
            resourceIdDto result = apiInstance.importMarcRecord(inventoryId, profileId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#importMarcRecord");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ResourceApi *apiInstance = [[ResourceApi alloc] init];
String *inventoryId = inventoryId_example; // Inventory ID (999 $i) of the MARC record in SRS (default to null)
Integer *profileId = 56; // ID of the profile (optional) (default to null)

[apiInstance importMarcRecordWith:inventoryId
    profileId:profileId
              completionHandler: ^(resourceIdDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ResourceApi()
var inventoryId = inventoryId_example; // {String} Inventory ID (999 $i) of the MARC record in SRS
var opts = {
  'profileId': 56 // {Integer} ID of the profile
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ResourceApi();
            var inventoryId = inventoryId_example;  // String | Inventory ID (999 $i) of the MARC record in SRS (default to null)
            var profileId = 56;  // Integer | ID of the profile (optional)  (default to null)

            try {
                resourceIdDto result = apiInstance.importMarcRecord(inventoryId, profileId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ResourceApi.importMarcRecord: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ResourceApi();
$inventoryId = inventoryId_example; // String | Inventory ID (999 $i) of the MARC record in SRS
$profileId = 56; // Integer | ID of the profile

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ResourceApi->new();
my $inventoryId = inventoryId_example; # String | Inventory ID (999 $i) of the MARC record in SRS
my $profileId = 56; # Integer | ID of the profile

eval {
    my $result = $api_instance->importMarcRecord(inventoryId => $inventoryId, profileId => $profileId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ResourceApi->importMarcRecord: $@\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.ResourceApi()
inventoryId = inventoryId_example # String | Inventory ID (999 $i) of the MARC record in SRS (default to null)
profileId = 56 # Integer | ID of the profile (optional) (default to null)

try:
    api_response = api_instance.import_marc_record(inventoryId, profileId=profileId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ResourceApi->importMarcRecord: %s\n" % e)

extern crate ResourceApi;

pub fn main() {
    let inventoryId = inventoryId_example; // String
    let profileId = 56; // Integer

    let mut context = ResourceApi::Context::default();
    let result = client.importMarcRecord(inventoryId, profileId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        ResourceApi apiInstance = new ResourceApi();
        Long id = 789; // Long | Linked Data resource id
        ResourceRequestDto resourceRequestDto = example/resourceRequest.sample; // ResourceRequestDto | 

        try {
            resourceResponseDto result = apiInstance.updateResource(id, resourceRequestDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#updateResource");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | Linked Data resource id
final ResourceRequestDto resourceRequestDto = new ResourceRequestDto(); // ResourceRequestDto | 

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

import org.openapitools.client.api.ResourceApi;

public class ResourceApiExample {
    public static void main(String[] args) {
        ResourceApi apiInstance = new ResourceApi();
        Long id = 789; // Long | Linked Data resource id
        ResourceRequestDto resourceRequestDto = example/resourceRequest.sample; // ResourceRequestDto | 

        try {
            resourceResponseDto result = apiInstance.updateResource(id, resourceRequestDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#updateResource");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ResourceApi *apiInstance = [[ResourceApi alloc] init];
Long *id = 789; // Linked Data resource id (default to null)
ResourceRequestDto *resourceRequestDto = example/resourceRequest.sample; //  (optional)

[apiInstance updateResourceWith:id
    resourceRequestDto:resourceRequestDto
              completionHandler: ^(resourceResponseDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ResourceApi()
var id = 789; // {Long} Linked Data resource id
var opts = {
  'resourceRequestDto': example/resourceRequest.sample // {ResourceRequestDto} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ResourceApi();
            var id = 789;  // Long | Linked Data resource id (default to null)
            var resourceRequestDto = new ResourceRequestDto(); // ResourceRequestDto |  (optional) 

            try {
                resourceResponseDto result = apiInstance.updateResource(id, resourceRequestDto);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ResourceApi.updateResource: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ResourceApi();
$id = 789; // Long | Linked Data resource id
$resourceRequestDto = example/resourceRequest.sample; // ResourceRequestDto | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ResourceApi->new();
my $id = 789; # Long | Linked Data resource id
my $resourceRequestDto = WWW::OPenAPIClient::Object::ResourceRequestDto->new(); # ResourceRequestDto | 

eval {
    my $result = $api_instance->updateResource(id => $id, resourceRequestDto => $resourceRequestDto);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ResourceApi->updateResource: $@\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.ResourceApi()
id = 789 # Long | Linked Data resource id (default to null)
resourceRequestDto = example/resourceRequest.sample # ResourceRequestDto |  (optional)

try:
    api_response = api_instance.update_resource(id, resourceRequestDto=resourceRequestDto)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ResourceApi->updateResource: %s\n" % e)

extern crate ResourceApi;

pub fn main() {
    let id = 789; // Long
    let resourceRequestDto = example/resourceRequest.sample; // ResourceRequestDto

    let mut context = ResourceApi::Context::default();
    let result = client.updateResource(id, resourceRequestDto, &context).wait();

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

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

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

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

        // Create an instance of the API class
        VocabularyApi apiInstance = new VocabularyApi();
        String vocabularyName = vocabularyName_example; // String | Vocabulary name

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String vocabularyName = new String(); // String | Vocabulary name

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

import org.openapitools.client.api.VocabularyApi;

public class VocabularyApiExample {
    public static void main(String[] args) {
        VocabularyApi apiInstance = new VocabularyApi();
        String vocabularyName = vocabularyName_example; // String | Vocabulary name

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

// Create an instance of the API class
VocabularyApi *apiInstance = [[VocabularyApi alloc] init];
String *vocabularyName = vocabularyName_example; // Vocabulary name (default to null)

[apiInstance getVocabularyByNameWith:vocabularyName
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.VocabularyApi()
var vocabularyName = vocabularyName_example; // {String} Vocabulary name

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

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

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

            // Create an instance of the API class
            var apiInstance = new VocabularyApi();
            var vocabularyName = vocabularyName_example;  // String | Vocabulary name (default to null)

            try {
                'String' result = apiInstance.getVocabularyByName(vocabularyName);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling VocabularyApi.getVocabularyByName: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\VocabularyApi();
$vocabularyName = vocabularyName_example; // String | Vocabulary name

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::VocabularyApi->new();
my $vocabularyName = vocabularyName_example; # String | Vocabulary name

eval {
    my $result = $api_instance->getVocabularyByName(vocabularyName => $vocabularyName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling VocabularyApi->getVocabularyByName: $@\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.VocabularyApi()
vocabularyName = vocabularyName_example # String | Vocabulary name (default to null)

try:
    api_response = api_instance.get_vocabulary_by_name(vocabularyName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling VocabularyApi->getVocabularyByName: %s\n" % e)

extern crate VocabularyApi;

pub fn main() {
    let vocabularyName = vocabularyName_example; // String

    let mut context = VocabularyApi::Context::default();
    let result = client.getVocabularyByName(vocabularyName, &context).wait();

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