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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID operationId = new UUID(); // UUID | UUID of the Bulk Operation

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation

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

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
UUID *operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID of the Bulk Operation (default to null)

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

var BulkOperationsApi = require('bulk_operations_api');

// Create an instance of the API class
var api = new BulkOperationsApi.DefaultApi()
var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} UUID of the Bulk Operation

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | UUID of the Bulk Operation (default to null)

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | UUID of the Bulk Operation

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | UUID of the Bulk Operation (default to null)

try:
    api_instance.cancel_operation_by_id(operationId)
except ApiException as e:
    print("Exception when calling DefaultApi->cancelOperationById: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

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

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.DefaultApi;

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

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

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

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

var BulkOperationsApi = require('bulk_operations_api');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate DefaultApi;

pub fn main() {

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

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ProfileRequest profileRequest = new ProfileRequest(); // ProfileRequest | 

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

import org.openapitools.client.api.DefaultApi;

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

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

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

[apiInstance createProfileWith:profileRequest
              completionHandler: ^(profileDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BulkOperationsApi = require('bulk_operations_api');

// Create an instance of the API class
var api = new BulkOperationsApi.DefaultApi()
var profileRequest = ; // {ProfileRequest} 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate DefaultApi;

pub fn main() {
    let profileRequest = ; // ProfileRequest

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

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation
        String fileName = fileName_example; // String | File name

        try {
            apiInstance.deleteFileByNameAndOperationId(operationId, fileName);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteFileByNameAndOperationId");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID operationId = new UUID(); // UUID | UUID of the Bulk Operation
final String fileName = new String(); // String | File name

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation
        String fileName = fileName_example; // String | File name

        try {
            apiInstance.deleteFileByNameAndOperationId(operationId, fileName);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteFileByNameAndOperationId");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
UUID *operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID of the Bulk Operation (default to null)
String *fileName = fileName_example; // File name (default to null)

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

var BulkOperationsApi = require('bulk_operations_api');

// Create an instance of the API class
var api = new BulkOperationsApi.DefaultApi()
var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} UUID of the Bulk Operation
var fileName = fileName_example; // {String} File name

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | UUID of the Bulk Operation (default to null)
            var fileName = fileName_example;  // String | File name (default to null)

            try {
                apiInstance.deleteFileByNameAndOperationId(operationId, fileName);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.deleteFileByNameAndOperationId: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation
$fileName = fileName_example; // String | File name

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | UUID of the Bulk Operation
my $fileName = fileName_example; # String | File name

eval {
    $api_instance->deleteFileByNameAndOperationId(operationId => $operationId, fileName => $fileName);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteFileByNameAndOperationId: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | UUID of the Bulk Operation (default to null)
fileName = fileName_example # String | File name (default to null)

try:
    api_instance.delete_file_by_name_and_operation_id(operationId, fileName)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteFileByNameAndOperationId: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let fileName = fileName_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.deleteFileByNameAndOperationId(operationId, fileName, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID id = new UUID(); // UUID | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

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

var BulkOperationsApi = require('bulk_operations_api');

// Create an instance of the API class
var api = new BulkOperationsApi.DefaultApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    api_instance.delete_profile(id)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteProfile: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

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

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation
        FileContentType fileContentType = ; // FileContentType | The file content type

        try {
            File result = apiInstance.downloadFileByOperationId(operationId, fileContentType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#downloadFileByOperationId");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID operationId = new UUID(); // UUID | UUID of the Bulk Operation
final FileContentType fileContentType = new FileContentType(); // FileContentType | The file content type

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation
        FileContentType fileContentType = ; // FileContentType | The file content type

        try {
            File result = apiInstance.downloadFileByOperationId(operationId, fileContentType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#downloadFileByOperationId");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
UUID *operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID of the Bulk Operation (default to null)
FileContentType *fileContentType = ; // The file content type (default to null)

[apiInstance downloadFileByOperationIdWith:operationId
    fileContentType:fileContentType
              completionHandler: ^(File output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BulkOperationsApi = require('bulk_operations_api');

// Create an instance of the API class
var api = new BulkOperationsApi.DefaultApi()
var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} UUID of the Bulk Operation
var fileContentType = ; // {FileContentType} The file content type

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | UUID of the Bulk Operation (default to null)
            var fileContentType = new FileContentType(); // FileContentType | The file content type (default to null)

            try {
                File result = apiInstance.downloadFileByOperationId(operationId, fileContentType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.downloadFileByOperationId: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation
$fileContentType = ; // FileContentType | The file content type

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | UUID of the Bulk Operation
my $fileContentType = ; # FileContentType | The file content type

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | UUID of the Bulk Operation (default to null)
fileContentType =  # FileContentType | The file content type (default to null)

try:
    api_response = api_instance.download_file_by_operation_id(operationId, fileContentType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->downloadFileByOperationId: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let fileContentType = ; // FileContentType

    let mut context = DefaultApi::Context::default();
    let result = client.downloadFileByOperationId(operationId, fileContentType, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID operationId = new UUID(); // UUID | UUID of the Bulk Operation

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation

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

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
UUID *operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID of the Bulk Operation (default to null)

[apiInstance getBulkOperationByIdWith:operationId
              completionHandler: ^(bulkOperationDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BulkOperationsApi = require('bulk_operations_api');

// Create an instance of the API class
var api = new BulkOperationsApi.DefaultApi()
var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} UUID of the Bulk Operation

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | UUID of the Bulk Operation (default to null)

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | UUID of the Bulk Operation

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | UUID of the Bulk Operation (default to null)

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

extern crate DefaultApi;

pub fn main() {
    let operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

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

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String query = query_example; // String | Request query
        Integer offset = 56; // Integer | Query offset
        Integer limit = 56; // Integer | Query limit

        try {
            bulkOperationCollection result = apiInstance.getBulkOperationCollection(query, offset, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getBulkOperationCollection");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String query = new String(); // String | Request query
final Integer offset = new Integer(); // Integer | Query offset
final Integer limit = new Integer(); // Integer | Query limit

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String query = query_example; // String | Request query
        Integer offset = 56; // Integer | Query offset
        Integer limit = 56; // Integer | Query limit

        try {
            bulkOperationCollection result = apiInstance.getBulkOperationCollection(query, offset, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getBulkOperationCollection");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *query = query_example; // Request query (default to null)
Integer *offset = 56; // Query offset (optional) (default to null)
Integer *limit = 56; // Query limit (optional) (default to null)

[apiInstance getBulkOperationCollectionWith:query
    offset:offset
    limit:limit
              completionHandler: ^(bulkOperationCollection output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BulkOperationsApi = require('bulk_operations_api');

// Create an instance of the API class
var api = new BulkOperationsApi.DefaultApi()
var query = query_example; // {String} Request query
var opts = {
  'offset': 56, // {Integer} Query offset
  'limit': 56 // {Integer} Query limit
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var query = query_example;  // String | Request query (default to null)
            var offset = 56;  // Integer | Query offset (optional)  (default to null)
            var limit = 56;  // Integer | Query limit (optional)  (default to null)

            try {
                bulkOperationCollection result = apiInstance.getBulkOperationCollection(query, offset, limit);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getBulkOperationCollection: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$query = query_example; // String | Request query
$offset = 56; // Integer | Query offset
$limit = 56; // Integer | Query limit

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $query = query_example; # String | Request query
my $offset = 56; # Integer | Query offset
my $limit = 56; # Integer | Query limit

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
query = query_example # String | Request query (default to null)
offset = 56 # Integer | Query offset (optional) (default to null)
limit = 56 # Integer | Query limit (optional) (default to null)

try:
    api_response = api_instance.get_bulk_operation_collection(query, offset=offset, limit=limit)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getBulkOperationCollection: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let query = query_example; // String
    let offset = 56; // Integer
    let limit = 56; // Integer

    let mut context = DefaultApi::Context::default();
    let result = client.getBulkOperationCollection(query, offset, limit, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation
        Integer limit = 56; // Integer | The numbers of errors to return
        Integer offset = 56; // Integer | Query offset
        ErrorType errorType = ; // ErrorType | The error type

        try {
            errors result = apiInstance.getErrorsPreviewByOperationId(operationId, limit, offset, errorType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getErrorsPreviewByOperationId");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID operationId = new UUID(); // UUID | UUID of the Bulk Operation
final Integer limit = new Integer(); // Integer | The numbers of errors to return
final Integer offset = new Integer(); // Integer | Query offset
final ErrorType errorType = new ErrorType(); // ErrorType | The error type

try {
    final result = await api_instance.getErrorsPreviewByOperationId(operationId, limit, offset, errorType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getErrorsPreviewByOperationId: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation
        Integer limit = 56; // Integer | The numbers of errors to return
        Integer offset = 56; // Integer | Query offset
        ErrorType errorType = ; // ErrorType | The error type

        try {
            errors result = apiInstance.getErrorsPreviewByOperationId(operationId, limit, offset, errorType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getErrorsPreviewByOperationId");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
UUID *operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID of the Bulk Operation (default to null)
Integer *limit = 56; // The numbers of errors to return (default to 10)
Integer *offset = 56; // Query offset (optional) (default to 0)
ErrorType *errorType = ; // The error type (optional) (default to null)

[apiInstance getErrorsPreviewByOperationIdWith:operationId
    limit:limit
    offset:offset
    errorType:errorType
              completionHandler: ^(errors output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BulkOperationsApi = require('bulk_operations_api');

// Create an instance of the API class
var api = new BulkOperationsApi.DefaultApi()
var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} UUID of the Bulk Operation
var limit = 56; // {Integer} The numbers of errors to return
var opts = {
  'offset': 56, // {Integer} Query offset
  'errorType':  // {ErrorType} The error type
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | UUID of the Bulk Operation (default to null)
            var limit = 56;  // Integer | The numbers of errors to return (default to 10)
            var offset = 56;  // Integer | Query offset (optional)  (default to 0)
            var errorType = new ErrorType(); // ErrorType | The error type (optional)  (default to null)

            try {
                errors result = apiInstance.getErrorsPreviewByOperationId(operationId, limit, offset, errorType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getErrorsPreviewByOperationId: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation
$limit = 56; // Integer | The numbers of errors to return
$offset = 56; // Integer | Query offset
$errorType = ; // ErrorType | The error type

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | UUID of the Bulk Operation
my $limit = 56; # Integer | The numbers of errors to return
my $offset = 56; # Integer | Query offset
my $errorType = ; # ErrorType | The error type

eval {
    my $result = $api_instance->getErrorsPreviewByOperationId(operationId => $operationId, limit => $limit, offset => $offset, errorType => $errorType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getErrorsPreviewByOperationId: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | UUID of the Bulk Operation (default to null)
limit = 56 # Integer | The numbers of errors to return (default to 10)
offset = 56 # Integer | Query offset (optional) (default to 0)
errorType =  # ErrorType | The error type (optional) (default to null)

try:
    api_response = api_instance.get_errors_preview_by_operation_id(operationId, limit, offset=offset, errorType=errorType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getErrorsPreviewByOperationId: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let limit = 56; // Integer
    let offset = 56; // Integer
    let errorType = ; // ErrorType

    let mut context = DefaultApi::Context::default();
    let result = client.getErrorsPreviewByOperationId(operationId, limit, offset, errorType, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID operationId = new UUID(); // UUID | UUID of the Bulk Operation

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation

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

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
UUID *operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID of the Bulk Operation (default to null)

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

var BulkOperationsApi = require('bulk_operations_api');

// Create an instance of the API class
var api = new BulkOperationsApi.DefaultApi()
var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} UUID of the Bulk Operation

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | UUID of the Bulk Operation (default to null)

            try {
                array['String'] result = apiInstance.getListUsedTenants(operationId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getListUsedTenants: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | UUID of the Bulk Operation

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | UUID of the Bulk Operation (default to null)

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

extern crate DefaultApi;

pub fn main() {
    let operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

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

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String query = query_example; // String | Request query
        Integer offset = 56; // Integer | Query offset
        Integer limit = 56; // Integer | Query limit

        try {
            users result = apiInstance.getListUsers(query, offset, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getListUsers");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String query = new String(); // String | Request query
final Integer offset = new Integer(); // Integer | Query offset
final Integer limit = new Integer(); // Integer | Query limit

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String query = query_example; // String | Request query
        Integer offset = 56; // Integer | Query offset
        Integer limit = 56; // Integer | Query limit

        try {
            users result = apiInstance.getListUsers(query, offset, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getListUsers");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *query = query_example; // Request query (default to null)
Integer *offset = 56; // Query offset (optional) (default to null)
Integer *limit = 56; // Query limit (optional) (default to null)

[apiInstance getListUsersWith:query
    offset:offset
    limit:limit
              completionHandler: ^(users output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BulkOperationsApi = require('bulk_operations_api');

// Create an instance of the API class
var api = new BulkOperationsApi.DefaultApi()
var query = query_example; // {String} Request query
var opts = {
  'offset': 56, // {Integer} Query offset
  'limit': 56 // {Integer} Query limit
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var query = query_example;  // String | Request query (default to null)
            var offset = 56;  // Integer | Query offset (optional)  (default to null)
            var limit = 56;  // Integer | Query limit (optional)  (default to null)

            try {
                users result = apiInstance.getListUsers(query, offset, limit);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getListUsers: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$query = query_example; // String | Request query
$offset = 56; // Integer | Query offset
$limit = 56; // Integer | Query limit

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $query = query_example; # String | Request query
my $offset = 56; # Integer | Query offset
my $limit = 56; # Integer | Query limit

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
query = query_example # String | Request query (default to null)
offset = 56 # Integer | Query offset (optional) (default to null)
limit = 56 # Integer | Query limit (optional) (default to null)

try:
    api_response = api_instance.get_list_users(query, offset=offset, limit=limit)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getListUsers: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let query = query_example; // String
    let offset = 56; // Integer
    let limit = 56; // Integer

    let mut context = DefaultApi::Context::default();
    let result = client.getListUsers(query, offset, limit, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation
        BulkOperationStep step = ; // BulkOperationStep | Key if manual approach is used
        Integer limit = 56; // Integer | The numbers of records to return
        Integer offset = 56; // Integer | Query offset

        try {
            unifiedTable result = apiInstance.getPreviewByOperationId(operationId, step, limit, offset);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getPreviewByOperationId");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID operationId = new UUID(); // UUID | UUID of the Bulk Operation
final BulkOperationStep step = new BulkOperationStep(); // BulkOperationStep | Key if manual approach is used
final Integer limit = new Integer(); // Integer | The numbers of records to return
final Integer offset = new Integer(); // Integer | Query offset

try {
    final result = await api_instance.getPreviewByOperationId(operationId, step, limit, offset);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getPreviewByOperationId: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation
        BulkOperationStep step = ; // BulkOperationStep | Key if manual approach is used
        Integer limit = 56; // Integer | The numbers of records to return
        Integer offset = 56; // Integer | Query offset

        try {
            unifiedTable result = apiInstance.getPreviewByOperationId(operationId, step, limit, offset);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getPreviewByOperationId");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
UUID *operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID of the Bulk Operation (default to null)
BulkOperationStep *step = ; // Key if manual approach is used (default to null)
Integer *limit = 56; // The numbers of records to return (default to null)
Integer *offset = 56; // Query offset (optional) (default to 0)

[apiInstance getPreviewByOperationIdWith:operationId
    step:step
    limit:limit
    offset:offset
              completionHandler: ^(unifiedTable output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BulkOperationsApi = require('bulk_operations_api');

// Create an instance of the API class
var api = new BulkOperationsApi.DefaultApi()
var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} UUID of the Bulk Operation
var step = ; // {BulkOperationStep} Key if manual approach is used
var limit = 56; // {Integer} The numbers of records to return
var opts = {
  'offset': 56 // {Integer} Query offset
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | UUID of the Bulk Operation (default to null)
            var step = new BulkOperationStep(); // BulkOperationStep | Key if manual approach is used (default to null)
            var limit = 56;  // Integer | The numbers of records to return (default to null)
            var offset = 56;  // Integer | Query offset (optional)  (default to 0)

            try {
                unifiedTable result = apiInstance.getPreviewByOperationId(operationId, step, limit, offset);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getPreviewByOperationId: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation
$step = ; // BulkOperationStep | Key if manual approach is used
$limit = 56; // Integer | The numbers of records to return
$offset = 56; // Integer | Query offset

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | UUID of the Bulk Operation
my $step = ; # BulkOperationStep | Key if manual approach is used
my $limit = 56; # Integer | The numbers of records to return
my $offset = 56; # Integer | Query offset

eval {
    my $result = $api_instance->getPreviewByOperationId(operationId => $operationId, step => $step, limit => $limit, offset => $offset);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getPreviewByOperationId: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | UUID of the Bulk Operation (default to null)
step =  # BulkOperationStep | Key if manual approach is used (default to null)
limit = 56 # Integer | The numbers of records to return (default to null)
offset = 56 # Integer | Query offset (optional) (default to 0)

try:
    api_response = api_instance.get_preview_by_operation_id(operationId, step, limit, offset=offset)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getPreviewByOperationId: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let step = ; // BulkOperationStep
    let limit = 56; // Integer
    let offset = 56; // Integer

    let mut context = DefaultApi::Context::default();
    let result = client.getPreviewByOperationId(operationId, step, limit, offset, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String query = query_example; // String | Request query
        Integer offset = 56; // Integer | Query offset
        Integer limit = 56; // Integer | Query limit

        try {
            profilesDto result = apiInstance.getProfiles(query, offset, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getProfiles");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String query = new String(); // String | Request query
final Integer offset = new Integer(); // Integer | Query offset
final Integer limit = new Integer(); // Integer | Query limit

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String query = query_example; // String | Request query
        Integer offset = 56; // Integer | Query offset
        Integer limit = 56; // Integer | Query limit

        try {
            profilesDto result = apiInstance.getProfiles(query, offset, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getProfiles");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *query = query_example; // Request query (optional) (default to null)
Integer *offset = 56; // Query offset (optional) (default to null)
Integer *limit = 56; // Query limit (optional) (default to null)

[apiInstance getProfilesWith:query
    offset:offset
    limit:limit
              completionHandler: ^(profilesDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BulkOperationsApi = require('bulk_operations_api');

// Create an instance of the API class
var api = new BulkOperationsApi.DefaultApi()
var opts = {
  'query': query_example, // {String} Request query
  'offset': 56, // {Integer} Query offset
  'limit': 56 // {Integer} Query limit
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var query = query_example;  // String | Request query (optional)  (default to null)
            var offset = 56;  // Integer | Query offset (optional)  (default to null)
            var limit = 56;  // Integer | Query limit (optional)  (default to null)

            try {
                profilesDto result = apiInstance.getProfiles(query, offset, limit);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getProfiles: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$query = query_example; // String | Request query
$offset = 56; // Integer | Query offset
$limit = 56; // Integer | Query limit

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $query = query_example; # String | Request query
my $offset = 56; # Integer | Query offset
my $limit = 56; # Integer | Query limit

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
query = query_example # String | Request query (optional) (default to null)
offset = 56 # Integer | Query offset (optional) (default to null)
limit = 56 # Integer | Query limit (optional) (default to null)

try:
    api_response = api_instance.get_profiles(query=query, offset=offset, limit=limit)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getProfiles: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let query = query_example; // String
    let offset = 56; // Integer
    let limit = 56; // Integer

    let mut context = DefaultApi::Context::default();
    let result = client.getProfiles(query, offset, limit, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation
        BulkOperationRuleCollection bulkOperationRuleCollection = ; // BulkOperationRuleCollection | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID operationId = new UUID(); // UUID | UUID of the Bulk Operation
final BulkOperationRuleCollection bulkOperationRuleCollection = new BulkOperationRuleCollection(); // BulkOperationRuleCollection | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation
        BulkOperationRuleCollection bulkOperationRuleCollection = ; // BulkOperationRuleCollection | 

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

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
UUID *operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID of the Bulk Operation (default to null)
BulkOperationRuleCollection *bulkOperationRuleCollection = ; // 

[apiInstance postContentUpdatesWith:operationId
    bulkOperationRuleCollection:bulkOperationRuleCollection
              completionHandler: ^(bulkOperationRuleCollection output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BulkOperationsApi = require('bulk_operations_api');

// Create an instance of the API class
var api = new BulkOperationsApi.DefaultApi()
var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} UUID of the Bulk Operation
var bulkOperationRuleCollection = ; // {BulkOperationRuleCollection} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | UUID of the Bulk Operation (default to null)
            var bulkOperationRuleCollection = new BulkOperationRuleCollection(); // BulkOperationRuleCollection | 

            try {
                bulkOperationRuleCollection result = apiInstance.postContentUpdates(operationId, bulkOperationRuleCollection);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.postContentUpdates: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation
$bulkOperationRuleCollection = ; // BulkOperationRuleCollection | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | UUID of the Bulk Operation
my $bulkOperationRuleCollection = WWW::OPenAPIClient::Object::BulkOperationRuleCollection->new(); # BulkOperationRuleCollection | 

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | UUID of the Bulk Operation (default to null)
bulkOperationRuleCollection =  # BulkOperationRuleCollection | 

try:
    api_response = api_instance.post_content_updates(operationId, bulkOperationRuleCollection)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->postContentUpdates: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let bulkOperationRuleCollection = ; // BulkOperationRuleCollection

    let mut context = DefaultApi::Context::default();
    let result = client.postContentUpdates(operationId, bulkOperationRuleCollection, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation
        BulkOperationMarcRuleCollection bulkOperationMarcRuleCollection = ; // BulkOperationMarcRuleCollection | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID operationId = new UUID(); // UUID | UUID of the Bulk Operation
final BulkOperationMarcRuleCollection bulkOperationMarcRuleCollection = new BulkOperationMarcRuleCollection(); // BulkOperationMarcRuleCollection | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation
        BulkOperationMarcRuleCollection bulkOperationMarcRuleCollection = ; // BulkOperationMarcRuleCollection | 

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

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
UUID *operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID of the Bulk Operation (default to null)
BulkOperationMarcRuleCollection *bulkOperationMarcRuleCollection = ; // 

[apiInstance postMarcContentUpdatesWith:operationId
    bulkOperationMarcRuleCollection:bulkOperationMarcRuleCollection
              completionHandler: ^(bulkOperationMarcRuleCollection output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BulkOperationsApi = require('bulk_operations_api');

// Create an instance of the API class
var api = new BulkOperationsApi.DefaultApi()
var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} UUID of the Bulk Operation
var bulkOperationMarcRuleCollection = ; // {BulkOperationMarcRuleCollection} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | UUID of the Bulk Operation (default to null)
            var bulkOperationMarcRuleCollection = new BulkOperationMarcRuleCollection(); // BulkOperationMarcRuleCollection | 

            try {
                bulkOperationMarcRuleCollection result = apiInstance.postMarcContentUpdates(operationId, bulkOperationMarcRuleCollection);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.postMarcContentUpdates: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation
$bulkOperationMarcRuleCollection = ; // BulkOperationMarcRuleCollection | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | UUID of the Bulk Operation
my $bulkOperationMarcRuleCollection = WWW::OPenAPIClient::Object::BulkOperationMarcRuleCollection->new(); # BulkOperationMarcRuleCollection | 

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | UUID of the Bulk Operation (default to null)
bulkOperationMarcRuleCollection =  # BulkOperationMarcRuleCollection | 

try:
    api_response = api_instance.post_marc_content_updates(operationId, bulkOperationMarcRuleCollection)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->postMarcContentUpdates: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let bulkOperationMarcRuleCollection = ; // BulkOperationMarcRuleCollection

    let mut context = DefaultApi::Context::default();
    let result = client.postMarcContentUpdates(operationId, bulkOperationMarcRuleCollection, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation
        BulkOperationStart bulkOperationStart = ; // BulkOperationStart | 
        UUID xOkapiUserId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            bulkOperationDto result = apiInstance.startBulkOperation(operationId, bulkOperationStart, xOkapiUserId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#startBulkOperation");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID operationId = new UUID(); // UUID | UUID of the Bulk Operation
final BulkOperationStart bulkOperationStart = new BulkOperationStart(); // BulkOperationStart | 
final UUID xOkapiUserId = new UUID(); // UUID | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation
        BulkOperationStart bulkOperationStart = ; // BulkOperationStart | 
        UUID xOkapiUserId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            bulkOperationDto result = apiInstance.startBulkOperation(operationId, bulkOperationStart, xOkapiUserId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#startBulkOperation");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
UUID *operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID of the Bulk Operation (default to null)
BulkOperationStart *bulkOperationStart = ; // 
UUID *xOkapiUserId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (optional) (default to null)

[apiInstance startBulkOperationWith:operationId
    bulkOperationStart:bulkOperationStart
    xOkapiUserId:xOkapiUserId
              completionHandler: ^(bulkOperationDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BulkOperationsApi = require('bulk_operations_api');

// Create an instance of the API class
var api = new BulkOperationsApi.DefaultApi()
var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} UUID of the Bulk Operation
var bulkOperationStart = ; // {BulkOperationStart} 
var opts = {
  'xOkapiUserId': 38400000-8cf0-11bd-b23e-10b96e4ef00d // {UUID} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | UUID of the Bulk Operation (default to null)
            var bulkOperationStart = new BulkOperationStart(); // BulkOperationStart | 
            var xOkapiUserId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (optional)  (default to null)

            try {
                bulkOperationDto result = apiInstance.startBulkOperation(operationId, bulkOperationStart, xOkapiUserId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.startBulkOperation: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation
$bulkOperationStart = ; // BulkOperationStart | 
$xOkapiUserId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | UUID of the Bulk Operation
my $bulkOperationStart = WWW::OPenAPIClient::Object::BulkOperationStart->new(); # BulkOperationStart | 
my $xOkapiUserId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | UUID of the Bulk Operation (default to null)
bulkOperationStart =  # BulkOperationStart | 
xOkapiUserId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (optional) (default to null)

try:
    api_response = api_instance.start_bulk_operation(operationId, bulkOperationStart, xOkapiUserId=xOkapiUserId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->startBulkOperation: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let bulkOperationStart = ; // BulkOperationStart
    let xOkapiUserId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = DefaultApi::Context::default();
    let result = client.startBulkOperation(operationId, bulkOperationStart, xOkapiUserId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        UUID xOkapiUserId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        QueryRequest queryRequest = ; // QueryRequest | 

        try {
            bulkOperationDto result = apiInstance.triggerBulkEditByQuery(xOkapiUserId, queryRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#triggerBulkEditByQuery");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID xOkapiUserId = new UUID(); // UUID | 
final QueryRequest queryRequest = new QueryRequest(); // QueryRequest | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        UUID xOkapiUserId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        QueryRequest queryRequest = ; // QueryRequest | 

        try {
            bulkOperationDto result = apiInstance.triggerBulkEditByQuery(xOkapiUserId, queryRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#triggerBulkEditByQuery");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
UUID *xOkapiUserId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (optional) (default to null)
QueryRequest *queryRequest = ; //  (optional)

[apiInstance triggerBulkEditByQueryWith:xOkapiUserId
    queryRequest:queryRequest
              completionHandler: ^(bulkOperationDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BulkOperationsApi = require('bulk_operations_api');

// Create an instance of the API class
var api = new BulkOperationsApi.DefaultApi()
var opts = {
  'xOkapiUserId': 38400000-8cf0-11bd-b23e-10b96e4ef00d, // {UUID} 
  'queryRequest':  // {QueryRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var xOkapiUserId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (optional)  (default to null)
            var queryRequest = new QueryRequest(); // QueryRequest |  (optional) 

            try {
                bulkOperationDto result = apiInstance.triggerBulkEditByQuery(xOkapiUserId, queryRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.triggerBulkEditByQuery: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$xOkapiUserId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$queryRequest = ; // QueryRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $xOkapiUserId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $queryRequest = WWW::OPenAPIClient::Object::QueryRequest->new(); # QueryRequest | 

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
xOkapiUserId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (optional) (default to null)
queryRequest =  # QueryRequest |  (optional)

try:
    api_response = api_instance.trigger_bulk_edit_by_query(xOkapiUserId=xOkapiUserId, queryRequest=queryRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->triggerBulkEditByQuery: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let xOkapiUserId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let queryRequest = ; // QueryRequest

    let mut context = DefaultApi::Context::default();
    let result = client.triggerBulkEditByQuery(xOkapiUserId, queryRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        ProfileRequest profileRequest = ; // ProfileRequest | 

        try {
            profileDto result = apiInstance.updateProfile(id, profileRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateProfile");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID id = new UUID(); // UUID | 
final ProfileRequest profileRequest = new ProfileRequest(); // ProfileRequest | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        ProfileRequest profileRequest = ; // ProfileRequest | 

        try {
            profileDto result = apiInstance.updateProfile(id, profileRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#updateProfile");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
ProfileRequest *profileRequest = ; // 

// Update a profile
[apiInstance updateProfileWith:id
    profileRequest:profileRequest
              completionHandler: ^(profileDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BulkOperationsApi = require('bulk_operations_api');

// Create an instance of the API class
var api = new BulkOperationsApi.DefaultApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var profileRequest = ; // {ProfileRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var profileRequest = new ProfileRequest(); // ProfileRequest | 

            try {
                // Update a profile
                profileDto result = apiInstance.updateProfile(id, profileRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.updateProfile: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$profileRequest = ; // ProfileRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $profileRequest = WWW::OPenAPIClient::Object::ProfileRequest->new(); # ProfileRequest | 

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
profileRequest =  # ProfileRequest | 

try:
    # Update a profile
    api_response = api_instance.update_profile(id, profileRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->updateProfile: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let profileRequest = ; // ProfileRequest

    let mut context = DefaultApi::Context::default();
    let result = client.updateProfile(id, profileRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        EntityType entityType = ; // EntityType | Entity type (USER, ITEM, HOLDINGS_RECORD)
        IdentifierType identifierType = ; // IdentifierType | Identifier type (ID, BARCODE, etc.)
        Boolean manual = true; // Boolean | Key if manual approach is used
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation (applicable for (manual = true) case)
        UUID xOkapiUserId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        File file = BINARY_DATA_HERE; // File | 

        try {
            bulkOperationDto result = apiInstance.uploadCsvFile(entityType, identifierType, manual, operationId, xOkapiUserId, file);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#uploadCsvFile");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final EntityType entityType = new EntityType(); // EntityType | Entity type (USER, ITEM, HOLDINGS_RECORD)
final IdentifierType identifierType = new IdentifierType(); // IdentifierType | Identifier type (ID, BARCODE, etc.)
final Boolean manual = new Boolean(); // Boolean | Key if manual approach is used
final UUID operationId = new UUID(); // UUID | UUID of the Bulk Operation (applicable for (manual = true) case)
final UUID xOkapiUserId = new UUID(); // UUID | 
final File file = new File(); // File | 

try {
    final result = await api_instance.uploadCsvFile(entityType, identifierType, manual, operationId, xOkapiUserId, file);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->uploadCsvFile: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        EntityType entityType = ; // EntityType | Entity type (USER, ITEM, HOLDINGS_RECORD)
        IdentifierType identifierType = ; // IdentifierType | Identifier type (ID, BARCODE, etc.)
        Boolean manual = true; // Boolean | Key if manual approach is used
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation (applicable for (manual = true) case)
        UUID xOkapiUserId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        File file = BINARY_DATA_HERE; // File | 

        try {
            bulkOperationDto result = apiInstance.uploadCsvFile(entityType, identifierType, manual, operationId, xOkapiUserId, file);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#uploadCsvFile");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
EntityType *entityType = ; // Entity type (USER, ITEM, HOLDINGS_RECORD) (default to null)
IdentifierType *identifierType = ; // Identifier type (ID, BARCODE, etc.) (default to null)
Boolean *manual = true; // Key if manual approach is used (optional) (default to false)
UUID *operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID of the Bulk Operation (applicable for (manual = true) case) (optional) (default to null)
UUID *xOkapiUserId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (optional) (default to null)
File *file = BINARY_DATA_HERE; //  (optional) (default to null)

[apiInstance uploadCsvFileWith:entityType
    identifierType:identifierType
    manual:manual
    operationId:operationId
    xOkapiUserId:xOkapiUserId
    file:file
              completionHandler: ^(bulkOperationDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BulkOperationsApi = require('bulk_operations_api');

// Create an instance of the API class
var api = new BulkOperationsApi.DefaultApi()
var entityType = ; // {EntityType} Entity type (USER, ITEM, HOLDINGS_RECORD)
var identifierType = ; // {IdentifierType} Identifier type (ID, BARCODE, etc.)
var opts = {
  'manual': true, // {Boolean} Key if manual approach is used
  'operationId': 38400000-8cf0-11bd-b23e-10b96e4ef00d, // {UUID} UUID of the Bulk Operation (applicable for (manual = true) case)
  'xOkapiUserId': 38400000-8cf0-11bd-b23e-10b96e4ef00d, // {UUID} 
  'file': 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.uploadCsvFile(entityType, identifierType, opts, callback);

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var entityType = new EntityType(); // EntityType | Entity type (USER, ITEM, HOLDINGS_RECORD) (default to null)
            var identifierType = new IdentifierType(); // IdentifierType | Identifier type (ID, BARCODE, etc.) (default to null)
            var manual = true;  // Boolean | Key if manual approach is used (optional)  (default to false)
            var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | UUID of the Bulk Operation (applicable for (manual = true) case) (optional)  (default to null)
            var xOkapiUserId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (optional)  (default to null)
            var file = BINARY_DATA_HERE;  // File |  (optional)  (default to null)

            try {
                bulkOperationDto result = apiInstance.uploadCsvFile(entityType, identifierType, manual, operationId, xOkapiUserId, file);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.uploadCsvFile: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$entityType = ; // EntityType | Entity type (USER, ITEM, HOLDINGS_RECORD)
$identifierType = ; // IdentifierType | Identifier type (ID, BARCODE, etc.)
$manual = true; // Boolean | Key if manual approach is used
$operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | UUID of the Bulk Operation (applicable for (manual = true) case)
$xOkapiUserId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$file = BINARY_DATA_HERE; // File | 

try {
    $result = $api_instance->uploadCsvFile($entityType, $identifierType, $manual, $operationId, $xOkapiUserId, $file);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->uploadCsvFile: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $entityType = ; # EntityType | Entity type (USER, ITEM, HOLDINGS_RECORD)
my $identifierType = ; # IdentifierType | Identifier type (ID, BARCODE, etc.)
my $manual = true; # Boolean | Key if manual approach is used
my $operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | UUID of the Bulk Operation (applicable for (manual = true) case)
my $xOkapiUserId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $file = BINARY_DATA_HERE; # File | 

eval {
    my $result = $api_instance->uploadCsvFile(entityType => $entityType, identifierType => $identifierType, manual => $manual, operationId => $operationId, xOkapiUserId => $xOkapiUserId, file => $file);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->uploadCsvFile: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
entityType =  # EntityType | Entity type (USER, ITEM, HOLDINGS_RECORD) (default to null)
identifierType =  # IdentifierType | Identifier type (ID, BARCODE, etc.) (default to null)
manual = true # Boolean | Key if manual approach is used (optional) (default to false)
operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | UUID of the Bulk Operation (applicable for (manual = true) case) (optional) (default to null)
xOkapiUserId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (optional) (default to null)
file = BINARY_DATA_HERE # File |  (optional) (default to null)

try:
    api_response = api_instance.upload_csv_file(entityType, identifierType, manual=manual, operationId=operationId, xOkapiUserId=xOkapiUserId, file=file)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->uploadCsvFile: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let entityType = ; // EntityType
    let identifierType = ; // IdentifierType
    let manual = true; // Boolean
    let operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let xOkapiUserId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let file = BINARY_DATA_HERE; // File

    let mut context = DefaultApi::Context::default();
    let result = client.uploadCsvFile(entityType, identifierType, manual, operationId, xOkapiUserId, file, &context).wait();

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