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

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

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

        // Create an instance of the API class
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        AtlasUserSavedSearch atlasUserSavedSearch = {"name":"...","ownerName":"...","searchParameters":{"attributes":["...","..."],"classification":"...","entityFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"GT"},"excludeDeletedEntities":true,"excludeHeaderAttributes":true,"includeClassificationAttributes":true,"includeSubClassifications":true,"includeSubTypes":true,"limit":12345,"marker":"...","offset":12345,"query":"...","relationshipFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"IN"},"relationshipName":"...","sortBy":"...","sortOrder":"DESCENDING","tagFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"NOT_EMPTY"},"termName":"...","typeName":"..."},"searchType":"BASIC","uiParameters":"...","guid":"..."}; // AtlasUserSavedSearch | 

        try {
            AtlasUserSavedSearch result = apiInstance.addSavedSearch(atlasUserSavedSearch);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#addSavedSearch");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final AtlasUserSavedSearch atlasUserSavedSearch = new AtlasUserSavedSearch(); // AtlasUserSavedSearch | 

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

import org.openapitools.client.api.DiscoveryRESTApi;

public class DiscoveryRESTApiExample {
    public static void main(String[] args) {
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        AtlasUserSavedSearch atlasUserSavedSearch = {"name":"...","ownerName":"...","searchParameters":{"attributes":["...","..."],"classification":"...","entityFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"GT"},"excludeDeletedEntities":true,"excludeHeaderAttributes":true,"includeClassificationAttributes":true,"includeSubClassifications":true,"includeSubTypes":true,"limit":12345,"marker":"...","offset":12345,"query":"...","relationshipFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"IN"},"relationshipName":"...","sortBy":"...","sortOrder":"DESCENDING","tagFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"NOT_EMPTY"},"termName":"...","typeName":"..."},"searchType":"BASIC","uiParameters":"...","guid":"..."}; // AtlasUserSavedSearch | 

        try {
            AtlasUserSavedSearch result = apiInstance.addSavedSearch(atlasUserSavedSearch);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#addSavedSearch");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];
AtlasUserSavedSearch *atlasUserSavedSearch = {"name":"...","ownerName":"...","searchParameters":{"attributes":["...","..."],"classification":"...","entityFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"GT"},"excludeDeletedEntities":true,"excludeHeaderAttributes":true,"includeClassificationAttributes":true,"includeSubClassifications":true,"includeSubTypes":true,"limit":12345,"marker":"...","offset":12345,"query":"...","relationshipFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"IN"},"relationshipName":"...","sortBy":"...","sortOrder":"DESCENDING","tagFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"NOT_EMPTY"},"termName":"...","typeName":"..."},"searchType":"BASIC","uiParameters":"...","guid":"..."}; //  (optional)

[apiInstance addSavedSearchWith:atlasUserSavedSearch
              completionHandler: ^(AtlasUserSavedSearch output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.DiscoveryRESTApi()
var opts = {
  'atlasUserSavedSearch': {"name":"...","ownerName":"...","searchParameters":{"attributes":["...","..."],"classification":"...","entityFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"GT"},"excludeDeletedEntities":true,"excludeHeaderAttributes":true,"includeClassificationAttributes":true,"includeSubClassifications":true,"includeSubTypes":true,"limit":12345,"marker":"...","offset":12345,"query":"...","relationshipFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"IN"},"relationshipName":"...","sortBy":"...","sortOrder":"DESCENDING","tagFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"NOT_EMPTY"},"termName":"...","typeName":"..."},"searchType":"BASIC","uiParameters":"...","guid":"..."} // {AtlasUserSavedSearch} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryRESTApi();
            var atlasUserSavedSearch = new AtlasUserSavedSearch(); // AtlasUserSavedSearch |  (optional) 

            try {
                AtlasUserSavedSearch result = apiInstance.addSavedSearch(atlasUserSavedSearch);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryRESTApi.addSavedSearch: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DiscoveryRESTApi();
$atlasUserSavedSearch = {"name":"...","ownerName":"...","searchParameters":{"attributes":["...","..."],"classification":"...","entityFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"GT"},"excludeDeletedEntities":true,"excludeHeaderAttributes":true,"includeClassificationAttributes":true,"includeSubClassifications":true,"includeSubTypes":true,"limit":12345,"marker":"...","offset":12345,"query":"...","relationshipFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"IN"},"relationshipName":"...","sortBy":"...","sortOrder":"DESCENDING","tagFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"NOT_EMPTY"},"termName":"...","typeName":"..."},"searchType":"BASIC","uiParameters":"...","guid":"..."}; // AtlasUserSavedSearch | 

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

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

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

eval {
    my $result = $api_instance->addSavedSearch(atlasUserSavedSearch => $atlasUserSavedSearch);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DiscoveryRESTApi->addSavedSearch: $@\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.DiscoveryRESTApi()
atlasUserSavedSearch = {"name":"...","ownerName":"...","searchParameters":{"attributes":["...","..."],"classification":"...","entityFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"GT"},"excludeDeletedEntities":true,"excludeHeaderAttributes":true,"includeClassificationAttributes":true,"includeSubClassifications":true,"includeSubTypes":true,"limit":12345,"marker":"...","offset":12345,"query":"...","relationshipFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"IN"},"relationshipName":"...","sortBy":"...","sortOrder":"DESCENDING","tagFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"NOT_EMPTY"},"termName":"...","typeName":"..."},"searchType":"BASIC","uiParameters":"...","guid":"..."} # AtlasUserSavedSearch |  (optional)

try:
    api_response = api_instance.add_saved_search(atlasUserSavedSearch=atlasUserSavedSearch)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DiscoveryRESTApi->addSavedSearch: %s\n" % e)

extern crate DiscoveryRESTApi;

pub fn main() {
    let atlasUserSavedSearch = {"name":"...","ownerName":"...","searchParameters":{"attributes":["...","..."],"classification":"...","entityFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"GT"},"excludeDeletedEntities":true,"excludeHeaderAttributes":true,"includeClassificationAttributes":true,"includeSubClassifications":true,"includeSubTypes":true,"limit":12345,"marker":"...","offset":12345,"query":"...","relationshipFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"IN"},"relationshipName":"...","sortBy":"...","sortOrder":"DESCENDING","tagFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"NOT_EMPTY"},"termName":"...","typeName":"..."},"searchType":"BASIC","uiParameters":"...","guid":"..."}; // AtlasUserSavedSearch

    let mut context = DiscoveryRESTApi::Context::default();
    let result = client.addSavedSearch(atlasUserSavedSearch, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        map[String, Object] requestBody = Object; // map[String, Object] | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final map[String, Object] requestBody = new map[String, Object](); // map[String, Object] | 

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

import org.openapitools.client.api.DiscoveryRESTApi;

public class DiscoveryRESTApiExample {
    public static void main(String[] args) {
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        map[String, Object] requestBody = Object; // map[String, Object] | 

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

// Create an instance of the API class
DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];
map[String, Object] *requestBody = Object; //  (optional)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.DiscoveryRESTApi()
var opts = {
  'requestBody': Object // {map[String, Object]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryRESTApi();
            var requestBody = new map[String, Object](); // map[String, Object] |  (optional) 

            try {
                apiInstance.basicSearchCreateFile(requestBody);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryRESTApi.basicSearchCreateFile: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DiscoveryRESTApi();
$requestBody = Object; // map[String, Object] | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DiscoveryRESTApi->new();
my $requestBody = WWW::OPenAPIClient::Object::map[String, Object]->new(); # map[String, Object] | 

eval {
    $api_instance->basicSearchCreateFile(requestBody => $requestBody);
};
if ($@) {
    warn "Exception when calling DiscoveryRESTApi->basicSearchCreateFile: $@\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.DiscoveryRESTApi()
requestBody = Object # map[String, Object] |  (optional)

try:
    api_instance.basic_search_create_file(requestBody=requestBody)
except ApiException as e:
    print("Exception when calling DiscoveryRESTApi->basicSearchCreateFile: %s\n" % e)

extern crate DiscoveryRESTApi;

pub fn main() {
    let requestBody = Object; // map[String, Object]

    let mut context = DiscoveryRESTApi::Context::default();
    let result = client.basicSearchCreateFile(requestBody, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        String guid = guid_example; // String | Name of the saved search

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String guid = new String(); // String | Name of the saved search

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

import org.openapitools.client.api.DiscoveryRESTApi;

public class DiscoveryRESTApiExample {
    public static void main(String[] args) {
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        String guid = guid_example; // String | Name of the saved search

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

// Create an instance of the API class
DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];
String *guid = guid_example; // Name of the saved search (default to null)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.DiscoveryRESTApi()
var guid = guid_example; // {String} Name of the saved search

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryRESTApi();
            var guid = guid_example;  // String | Name of the saved search (default to null)

            try {
                apiInstance.deleteSavedSearch(guid);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryRESTApi.deleteSavedSearch: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DiscoveryRESTApi();
$guid = guid_example; // String | Name of the saved search

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DiscoveryRESTApi->new();
my $guid = guid_example; # String | Name of the saved search

eval {
    $api_instance->deleteSavedSearch(guid => $guid);
};
if ($@) {
    warn "Exception when calling DiscoveryRESTApi->deleteSavedSearch: $@\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.DiscoveryRESTApi()
guid = guid_example # String | Name of the saved search (default to null)

try:
    api_instance.delete_saved_search(guid)
except ApiException as e:
    print("Exception when calling DiscoveryRESTApi->deleteSavedSearch: %s\n" % e)

extern crate DiscoveryRESTApi;

pub fn main() {
    let guid = guid_example; // String

    let mut context = DiscoveryRESTApi::Context::default();
    let result = client.deleteSavedSearch(guid, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        String filename = filename_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.DiscoveryRESTApi;

public class DiscoveryRESTApiExample {
    public static void main(String[] args) {
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        String filename = filename_example; // String | 

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

// Create an instance of the API class
DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];
String *filename = filename_example; //  (default to null)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.DiscoveryRESTApi()
var filename = filename_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryRESTApi();
            var filename = filename_example;  // String |  (default to null)

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DiscoveryRESTApi();
$filename = filename_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DiscoveryRESTApi->new();
my $filename = filename_example; # String | 

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

try:
    api_response = api_instance.download_search_result_file(filename)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DiscoveryRESTApi->downloadSearchResultFile: %s\n" % e)

extern crate DiscoveryRESTApi;

pub fn main() {
    let filename = filename_example; // String

    let mut context = DiscoveryRESTApi::Context::default();
    let result = client.downloadSearchResultFile(filename, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        map[String, Object] requestBody = Object; // map[String, Object] | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final map[String, Object] requestBody = new map[String, Object](); // map[String, Object] | 

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

import org.openapitools.client.api.DiscoveryRESTApi;

public class DiscoveryRESTApiExample {
    public static void main(String[] args) {
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        map[String, Object] requestBody = Object; // map[String, Object] | 

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

// Create an instance of the API class
DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];
map[String, Object] *requestBody = Object; //  (optional)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.DiscoveryRESTApi()
var opts = {
  'requestBody': Object // {map[String, Object]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryRESTApi();
            var requestBody = new map[String, Object](); // map[String, Object] |  (optional) 

            try {
                apiInstance.dslSearchCreateFile(requestBody);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryRESTApi.dslSearchCreateFile: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DiscoveryRESTApi();
$requestBody = Object; // map[String, Object] | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DiscoveryRESTApi->new();
my $requestBody = WWW::OPenAPIClient::Object::map[String, Object]->new(); # map[String, Object] | 

eval {
    $api_instance->dslSearchCreateFile(requestBody => $requestBody);
};
if ($@) {
    warn "Exception when calling DiscoveryRESTApi->dslSearchCreateFile: $@\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.DiscoveryRESTApi()
requestBody = Object # map[String, Object] |  (optional)

try:
    api_instance.dsl_search_create_file(requestBody=requestBody)
except ApiException as e:
    print("Exception when calling DiscoveryRESTApi->dslSearchCreateFile: %s\n" % e)

extern crate DiscoveryRESTApi;

pub fn main() {
    let requestBody = Object; // map[String, Object]

    let mut context = DiscoveryRESTApi::Context::default();
    let result = client.dslSearchCreateFile(requestBody, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        String guid = guid_example; // String | Guid identifying saved search

        try {
            AtlasSearchResult result = apiInstance.executeSavedSearchByGuid(guid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#executeSavedSearchByGuid");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String guid = new String(); // String | Guid identifying saved search

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

import org.openapitools.client.api.DiscoveryRESTApi;

public class DiscoveryRESTApiExample {
    public static void main(String[] args) {
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        String guid = guid_example; // String | Guid identifying saved search

        try {
            AtlasSearchResult result = apiInstance.executeSavedSearchByGuid(guid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#executeSavedSearchByGuid");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];
String *guid = guid_example; // Guid identifying saved search (default to null)

[apiInstance executeSavedSearchByGuidWith:guid
              completionHandler: ^(AtlasSearchResult output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.DiscoveryRESTApi()
var guid = guid_example; // {String} Guid identifying saved search

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryRESTApi();
            var guid = guid_example;  // String | Guid identifying saved search (default to null)

            try {
                AtlasSearchResult result = apiInstance.executeSavedSearchByGuid(guid);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryRESTApi.executeSavedSearchByGuid: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DiscoveryRESTApi();
$guid = guid_example; // String | Guid identifying saved search

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DiscoveryRESTApi->new();
my $guid = guid_example; # String | Guid identifying saved search

eval {
    my $result = $api_instance->executeSavedSearchByGuid(guid => $guid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DiscoveryRESTApi->executeSavedSearchByGuid: $@\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.DiscoveryRESTApi()
guid = guid_example # String | Guid identifying saved search (default to null)

try:
    api_response = api_instance.execute_saved_search_by_guid(guid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DiscoveryRESTApi->executeSavedSearchByGuid: %s\n" % e)

extern crate DiscoveryRESTApi;

pub fn main() {
    let guid = guid_example; // String

    let mut context = DiscoveryRESTApi::Context::default();
    let result = client.executeSavedSearchByGuid(guid, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        String name = name_example; // String | name of saved-search
        String user = user_example; // String | saved-search owner

        try {
            AtlasSearchResult result = apiInstance.executeSavedSearchByName(name, user);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#executeSavedSearchByName");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String name = new String(); // String | name of saved-search
final String user = new String(); // String | saved-search owner

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

import org.openapitools.client.api.DiscoveryRESTApi;

public class DiscoveryRESTApiExample {
    public static void main(String[] args) {
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        String name = name_example; // String | name of saved-search
        String user = user_example; // String | saved-search owner

        try {
            AtlasSearchResult result = apiInstance.executeSavedSearchByName(name, user);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#executeSavedSearchByName");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];
String *name = name_example; // name of saved-search (default to null)
String *user = user_example; // saved-search owner (optional) (default to null)

[apiInstance executeSavedSearchByNameWith:name
    user:user
              completionHandler: ^(AtlasSearchResult output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.DiscoveryRESTApi()
var name = name_example; // {String} name of saved-search
var opts = {
  'user': user_example // {String} saved-search owner
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryRESTApi();
            var name = name_example;  // String | name of saved-search (default to null)
            var user = user_example;  // String | saved-search owner (optional)  (default to null)

            try {
                AtlasSearchResult result = apiInstance.executeSavedSearchByName(name, user);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryRESTApi.executeSavedSearchByName: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DiscoveryRESTApi();
$name = name_example; // String | name of saved-search
$user = user_example; // String | saved-search owner

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DiscoveryRESTApi->new();
my $name = name_example; # String | name of saved-search
my $user = user_example; # String | saved-search owner

eval {
    my $result = $api_instance->executeSavedSearchByName(name => $name, user => $user);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DiscoveryRESTApi->executeSavedSearchByName: $@\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.DiscoveryRESTApi()
name = name_example # String | name of saved-search (default to null)
user = user_example # String | saved-search owner (optional) (default to null)

try:
    api_response = api_instance.execute_saved_search_by_name(name, user=user)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DiscoveryRESTApi->executeSavedSearchByName: %s\n" % e)

extern crate DiscoveryRESTApi;

pub fn main() {
    let name = name_example; // String
    let user = user_example; // String

    let mut context = DiscoveryRESTApi::Context::default();
    let result = client.executeSavedSearchByName(name, user, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        String name = name_example; // String | Name of the saved search
        String user = user_example; // String | User for whom the search is retrieved

        try {
            AtlasUserSavedSearch result = apiInstance.getSavedSearch(name, user);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#getSavedSearch");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String name = new String(); // String | Name of the saved search
final String user = new String(); // String | User for whom the search is retrieved

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

import org.openapitools.client.api.DiscoveryRESTApi;

public class DiscoveryRESTApiExample {
    public static void main(String[] args) {
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        String name = name_example; // String | Name of the saved search
        String user = user_example; // String | User for whom the search is retrieved

        try {
            AtlasUserSavedSearch result = apiInstance.getSavedSearch(name, user);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#getSavedSearch");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];
String *name = name_example; // Name of the saved search (default to null)
String *user = user_example; // User for whom the search is retrieved (optional) (default to null)

[apiInstance getSavedSearchWith:name
    user:user
              completionHandler: ^(AtlasUserSavedSearch output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.DiscoveryRESTApi()
var name = name_example; // {String} Name of the saved search
var opts = {
  'user': user_example // {String} User for whom the search is retrieved
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryRESTApi();
            var name = name_example;  // String | Name of the saved search (default to null)
            var user = user_example;  // String | User for whom the search is retrieved (optional)  (default to null)

            try {
                AtlasUserSavedSearch result = apiInstance.getSavedSearch(name, user);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryRESTApi.getSavedSearch: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DiscoveryRESTApi();
$name = name_example; // String | Name of the saved search
$user = user_example; // String | User for whom the search is retrieved

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DiscoveryRESTApi->new();
my $name = name_example; # String | Name of the saved search
my $user = user_example; # String | User for whom the search is retrieved

eval {
    my $result = $api_instance->getSavedSearch(name => $name, user => $user);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DiscoveryRESTApi->getSavedSearch: $@\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.DiscoveryRESTApi()
name = name_example # String | Name of the saved search (default to null)
user = user_example # String | User for whom the search is retrieved (optional) (default to null)

try:
    api_response = api_instance.get_saved_search(name, user=user)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DiscoveryRESTApi->getSavedSearch: %s\n" % e)

extern crate DiscoveryRESTApi;

pub fn main() {
    let name = name_example; // String
    let user = user_example; // String

    let mut context = DiscoveryRESTApi::Context::default();
    let result = client.getSavedSearch(name, user, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        String user = user_example; // String | User for whom the search is retrieved

        try {
            array[AtlasUserSavedSearch] result = apiInstance.getSavedSearches(user);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#getSavedSearches");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String user = new String(); // String | User for whom the search is retrieved

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

import org.openapitools.client.api.DiscoveryRESTApi;

public class DiscoveryRESTApiExample {
    public static void main(String[] args) {
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        String user = user_example; // String | User for whom the search is retrieved

        try {
            array[AtlasUserSavedSearch] result = apiInstance.getSavedSearches(user);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#getSavedSearches");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];
String *user = user_example; // User for whom the search is retrieved (optional) (default to null)

[apiInstance getSavedSearchesWith:user
              completionHandler: ^(array[AtlasUserSavedSearch] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.DiscoveryRESTApi()
var opts = {
  'user': user_example // {String} User for whom the search is retrieved
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryRESTApi();
            var user = user_example;  // String | User for whom the search is retrieved (optional)  (default to null)

            try {
                array[AtlasUserSavedSearch] result = apiInstance.getSavedSearches(user);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryRESTApi.getSavedSearches: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DiscoveryRESTApi();
$user = user_example; // String | User for whom the search is retrieved

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DiscoveryRESTApi->new();
my $user = user_example; # String | User for whom the search is retrieved

eval {
    my $result = $api_instance->getSavedSearches(user => $user);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DiscoveryRESTApi->getSavedSearches: $@\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.DiscoveryRESTApi()
user = user_example # String | User for whom the search is retrieved (optional) (default to null)

try:
    api_response = api_instance.get_saved_searches(user=user)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DiscoveryRESTApi->getSavedSearches: %s\n" % e)

extern crate DiscoveryRESTApi;

pub fn main() {
    let user = user_example; // String

    let mut context = DiscoveryRESTApi::Context::default();
    let result = client.getSavedSearches(user, &context).wait();

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

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

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

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

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

        try {
            AtlasSearchResultDownloadStatus result = apiInstance.getSearchResultDownloadStatus();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#getSearchResultDownloadStatus");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.DiscoveryRESTApi;

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

        try {
            AtlasSearchResultDownloadStatus result = apiInstance.getSearchResultDownloadStatus();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#getSearchResultDownloadStatus");
            e.printStackTrace();
        }
    }
}

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

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

var AtlasRestApi = require('atlas_rest_api');

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

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

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

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

            try {
                AtlasSearchResultDownloadStatus result = apiInstance.getSearchResultDownloadStatus();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryRESTApi.getSearchResultDownloadStatus: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate DiscoveryRESTApi;

pub fn main() {

    let mut context = DiscoveryRESTApi::Context::default();
    let result = client.getSearchResultDownloadStatus(&context).wait();

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

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

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

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

        // Create an instance of the API class
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        String fieldName = fieldName_example; // String | 
        String prefixString = prefixString_example; // String | 

        try {
            AtlasSuggestionsResult result = apiInstance.getSuggestions(fieldName, prefixString);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#getSuggestions");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String fieldName = new String(); // String | 
final String prefixString = new String(); // String | 

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

import org.openapitools.client.api.DiscoveryRESTApi;

public class DiscoveryRESTApiExample {
    public static void main(String[] args) {
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        String fieldName = fieldName_example; // String | 
        String prefixString = prefixString_example; // String | 

        try {
            AtlasSuggestionsResult result = apiInstance.getSuggestions(fieldName, prefixString);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#getSuggestions");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];
String *fieldName = fieldName_example; //  (optional) (default to null)
String *prefixString = prefixString_example; //  (optional) (default to null)

[apiInstance getSuggestionsWith:fieldName
    prefixString:prefixString
              completionHandler: ^(AtlasSuggestionsResult output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.DiscoveryRESTApi()
var opts = {
  'fieldName': fieldName_example, // {String} 
  'prefixString': prefixString_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryRESTApi();
            var fieldName = fieldName_example;  // String |  (optional)  (default to null)
            var prefixString = prefixString_example;  // String |  (optional)  (default to null)

            try {
                AtlasSuggestionsResult result = apiInstance.getSuggestions(fieldName, prefixString);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryRESTApi.getSuggestions: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DiscoveryRESTApi();
$fieldName = fieldName_example; // String | 
$prefixString = prefixString_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DiscoveryRESTApi->new();
my $fieldName = fieldName_example; # String | 
my $prefixString = prefixString_example; # String | 

eval {
    my $result = $api_instance->getSuggestions(fieldName => $fieldName, prefixString => $prefixString);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DiscoveryRESTApi->getSuggestions: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.DiscoveryRESTApi()
fieldName = fieldName_example # String |  (optional) (default to null)
prefixString = prefixString_example # String |  (optional) (default to null)

try:
    api_response = api_instance.get_suggestions(fieldName=fieldName, prefixString=prefixString)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DiscoveryRESTApi->getSuggestions: %s\n" % e)

extern crate DiscoveryRESTApi;

pub fn main() {
    let fieldName = fieldName_example; // String
    let prefixString = prefixString_example; // String

    let mut context = DiscoveryRESTApi::Context::default();
    let result = client.getSuggestions(fieldName, prefixString, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        Boolean excludeDeletedEntities = true; // Boolean | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String query = query_example; // String | 
        String sortBy = sortBy_example; // String | 
        String sortOrder = sortOrder_example; // String | 
        String typeName = typeName_example; // String | 

        try {
            apiInstance.quickSearch(excludeDeletedEntities, limit, offset, query, sortBy, sortOrder, typeName);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#quickSearch");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Boolean excludeDeletedEntities = new Boolean(); // Boolean | 
final Integer limit = new Integer(); // Integer | 
final Integer offset = new Integer(); // Integer | 
final String query = new String(); // String | 
final String sortBy = new String(); // String | 
final String sortOrder = new String(); // String | 
final String typeName = new String(); // String | 

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

import org.openapitools.client.api.DiscoveryRESTApi;

public class DiscoveryRESTApiExample {
    public static void main(String[] args) {
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        Boolean excludeDeletedEntities = true; // Boolean | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String query = query_example; // String | 
        String sortBy = sortBy_example; // String | 
        String sortOrder = sortOrder_example; // String | 
        String typeName = typeName_example; // String | 

        try {
            apiInstance.quickSearch(excludeDeletedEntities, limit, offset, query, sortBy, sortOrder, typeName);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#quickSearch");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];
Boolean *excludeDeletedEntities = true; //  (default to null)
Integer *limit = 56; //  (default to null)
Integer *offset = 56; //  (default to null)
String *query = query_example; //  (optional) (default to null)
String *sortBy = sortBy_example; //  (optional) (default to null)
String *sortOrder = sortOrder_example; //  (optional) (default to null)
String *typeName = typeName_example; //  (optional) (default to null)

[apiInstance quickSearchWith:excludeDeletedEntities
    limit:limit
    offset:offset
    query:query
    sortBy:sortBy
    sortOrder:sortOrder
    typeName:typeName
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.DiscoveryRESTApi()
var excludeDeletedEntities = true; // {Boolean} 
var limit = 56; // {Integer} 
var offset = 56; // {Integer} 
var opts = {
  'query': query_example, // {String} 
  'sortBy': sortBy_example, // {String} 
  'sortOrder': sortOrder_example, // {String} 
  'typeName': typeName_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryRESTApi();
            var excludeDeletedEntities = true;  // Boolean |  (default to null)
            var limit = 56;  // Integer |  (default to null)
            var offset = 56;  // Integer |  (default to null)
            var query = query_example;  // String |  (optional)  (default to null)
            var sortBy = sortBy_example;  // String |  (optional)  (default to null)
            var sortOrder = sortOrder_example;  // String |  (optional)  (default to null)
            var typeName = typeName_example;  // String |  (optional)  (default to null)

            try {
                apiInstance.quickSearch(excludeDeletedEntities, limit, offset, query, sortBy, sortOrder, typeName);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryRESTApi.quickSearch: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DiscoveryRESTApi();
$excludeDeletedEntities = true; // Boolean | 
$limit = 56; // Integer | 
$offset = 56; // Integer | 
$query = query_example; // String | 
$sortBy = sortBy_example; // String | 
$sortOrder = sortOrder_example; // String | 
$typeName = typeName_example; // String | 

try {
    $api_instance->quickSearch($excludeDeletedEntities, $limit, $offset, $query, $sortBy, $sortOrder, $typeName);
} catch (Exception $e) {
    echo 'Exception when calling DiscoveryRESTApi->quickSearch: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DiscoveryRESTApi->new();
my $excludeDeletedEntities = true; # Boolean | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $query = query_example; # String | 
my $sortBy = sortBy_example; # String | 
my $sortOrder = sortOrder_example; # String | 
my $typeName = typeName_example; # String | 

eval {
    $api_instance->quickSearch(excludeDeletedEntities => $excludeDeletedEntities, limit => $limit, offset => $offset, query => $query, sortBy => $sortBy, sortOrder => $sortOrder, typeName => $typeName);
};
if ($@) {
    warn "Exception when calling DiscoveryRESTApi->quickSearch: $@\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.DiscoveryRESTApi()
excludeDeletedEntities = true # Boolean |  (default to null)
limit = 56 # Integer |  (default to null)
offset = 56 # Integer |  (default to null)
query = query_example # String |  (optional) (default to null)
sortBy = sortBy_example # String |  (optional) (default to null)
sortOrder = sortOrder_example # String |  (optional) (default to null)
typeName = typeName_example # String |  (optional) (default to null)

try:
    api_instance.quick_search(excludeDeletedEntities, limit, offset, query=query, sortBy=sortBy, sortOrder=sortOrder, typeName=typeName)
except ApiException as e:
    print("Exception when calling DiscoveryRESTApi->quickSearch: %s\n" % e)

extern crate DiscoveryRESTApi;

pub fn main() {
    let excludeDeletedEntities = true; // Boolean
    let limit = 56; // Integer
    let offset = 56; // Integer
    let query = query_example; // String
    let sortBy = sortBy_example; // String
    let sortOrder = sortOrder_example; // String
    let typeName = typeName_example; // String

    let mut context = DiscoveryRESTApi::Context::default();
    let result = client.quickSearch(excludeDeletedEntities, limit, offset, query, sortBy, sortOrder, typeName, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        QuickSearchParameters quickSearchParameters = {"attributes":["...","..."],"entityFilters":{"attributeName":"...","attributeValue":"...","condition":"AND","criterion":[{},{}],"operator":"CONTAINS"},"excludeDeletedEntities":true,"excludeHeaderAttributes":true,"includeSubTypes":true,"limit":12345,"offset":12345,"query":"...","sortBy":"...","sortOrder":"DESCENDING","typeName":"..."}; // QuickSearchParameters | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final QuickSearchParameters quickSearchParameters = new QuickSearchParameters(); // QuickSearchParameters | 

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

import org.openapitools.client.api.DiscoveryRESTApi;

public class DiscoveryRESTApiExample {
    public static void main(String[] args) {
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        QuickSearchParameters quickSearchParameters = {"attributes":["...","..."],"entityFilters":{"attributeName":"...","attributeValue":"...","condition":"AND","criterion":[{},{}],"operator":"CONTAINS"},"excludeDeletedEntities":true,"excludeHeaderAttributes":true,"includeSubTypes":true,"limit":12345,"offset":12345,"query":"...","sortBy":"...","sortOrder":"DESCENDING","typeName":"..."}; // QuickSearchParameters | 

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

// Create an instance of the API class
DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];
QuickSearchParameters *quickSearchParameters = {"attributes":["...","..."],"entityFilters":{"attributeName":"...","attributeValue":"...","condition":"AND","criterion":[{},{}],"operator":"CONTAINS"},"excludeDeletedEntities":true,"excludeHeaderAttributes":true,"includeSubTypes":true,"limit":12345,"offset":12345,"query":"...","sortBy":"...","sortOrder":"DESCENDING","typeName":"..."}; //  (optional)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.DiscoveryRESTApi()
var opts = {
  'quickSearchParameters': {"attributes":["...","..."],"entityFilters":{"attributeName":"...","attributeValue":"...","condition":"AND","criterion":[{},{}],"operator":"CONTAINS"},"excludeDeletedEntities":true,"excludeHeaderAttributes":true,"includeSubTypes":true,"limit":12345,"offset":12345,"query":"...","sortBy":"...","sortOrder":"DESCENDING","typeName":"..."} // {QuickSearchParameters} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryRESTApi();
            var quickSearchParameters = new QuickSearchParameters(); // QuickSearchParameters |  (optional) 

            try {
                apiInstance.quickSearch2(quickSearchParameters);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryRESTApi.quickSearch2: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DiscoveryRESTApi();
$quickSearchParameters = {"attributes":["...","..."],"entityFilters":{"attributeName":"...","attributeValue":"...","condition":"AND","criterion":[{},{}],"operator":"CONTAINS"},"excludeDeletedEntities":true,"excludeHeaderAttributes":true,"includeSubTypes":true,"limit":12345,"offset":12345,"query":"...","sortBy":"...","sortOrder":"DESCENDING","typeName":"..."}; // QuickSearchParameters | 

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

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

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

eval {
    $api_instance->quickSearch2(quickSearchParameters => $quickSearchParameters);
};
if ($@) {
    warn "Exception when calling DiscoveryRESTApi->quickSearch2: $@\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.DiscoveryRESTApi()
quickSearchParameters = {"attributes":["...","..."],"entityFilters":{"attributeName":"...","attributeValue":"...","condition":"AND","criterion":[{},{}],"operator":"CONTAINS"},"excludeDeletedEntities":true,"excludeHeaderAttributes":true,"includeSubTypes":true,"limit":12345,"offset":12345,"query":"...","sortBy":"...","sortOrder":"DESCENDING","typeName":"..."} # QuickSearchParameters |  (optional)

try:
    api_instance.quick_search2(quickSearchParameters=quickSearchParameters)
except ApiException as e:
    print("Exception when calling DiscoveryRESTApi->quickSearch2: %s\n" % e)

extern crate DiscoveryRESTApi;

pub fn main() {
    let quickSearchParameters = {"attributes":["...","..."],"entityFilters":{"attributeName":"...","attributeValue":"...","condition":"AND","criterion":[{},{}],"operator":"CONTAINS"},"excludeDeletedEntities":true,"excludeHeaderAttributes":true,"includeSubTypes":true,"limit":12345,"offset":12345,"query":"...","sortBy":"...","sortOrder":"DESCENDING","typeName":"..."}; // QuickSearchParameters

    let mut context = DiscoveryRESTApi::Context::default();
    let result = client.quickSearch2(quickSearchParameters, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        Integer limit = 56; // Integer | limit the result set to only include the specified number of entries
        Integer offset = 56; // Integer | start offset of the result set (useful for pagination)
        String marker = marker_example; // String | 
        String relationshipName = relationshipName_example; // String | AtlasRelationshipType name
        String sortBy = sortBy_example; // String | sort the result using this attribute name, default value is 'name'
        String sortOrder = sortOrder_example; // String | sorting order

        try {
            apiInstance.relationSearch(limit, offset, marker, relationshipName, sortBy, sortOrder);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#relationSearch");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer limit = new Integer(); // Integer | limit the result set to only include the specified number of entries
final Integer offset = new Integer(); // Integer | start offset of the result set (useful for pagination)
final String marker = new String(); // String | 
final String relationshipName = new String(); // String | AtlasRelationshipType name
final String sortBy = new String(); // String | sort the result using this attribute name, default value is 'name'
final String sortOrder = new String(); // String | sorting order

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

import org.openapitools.client.api.DiscoveryRESTApi;

public class DiscoveryRESTApiExample {
    public static void main(String[] args) {
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        Integer limit = 56; // Integer | limit the result set to only include the specified number of entries
        Integer offset = 56; // Integer | start offset of the result set (useful for pagination)
        String marker = marker_example; // String | 
        String relationshipName = relationshipName_example; // String | AtlasRelationshipType name
        String sortBy = sortBy_example; // String | sort the result using this attribute name, default value is 'name'
        String sortOrder = sortOrder_example; // String | sorting order

        try {
            apiInstance.relationSearch(limit, offset, marker, relationshipName, sortBy, sortOrder);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#relationSearch");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];
Integer *limit = 56; // limit the result set to only include the specified number of entries (default to null)
Integer *offset = 56; // start offset of the result set (useful for pagination) (default to null)
String *marker = marker_example; //  (optional) (default to null)
String *relationshipName = relationshipName_example; // AtlasRelationshipType name (optional) (default to null)
String *sortBy = sortBy_example; // sort the result using this attribute name, default value is 'name' (optional) (default to null)
String *sortOrder = sortOrder_example; // sorting order (optional) (default to null)

[apiInstance relationSearchWith:limit
    offset:offset
    marker:marker
    relationshipName:relationshipName
    sortBy:sortBy
    sortOrder:sortOrder
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.DiscoveryRESTApi()
var limit = 56; // {Integer} limit the result set to only include the specified number of entries
var offset = 56; // {Integer} start offset of the result set (useful for pagination)
var opts = {
  'marker': marker_example, // {String} 
  'relationshipName': relationshipName_example, // {String} AtlasRelationshipType name
  'sortBy': sortBy_example, // {String} sort the result using this attribute name, default value is 'name'
  'sortOrder': sortOrder_example // {String} sorting order
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryRESTApi();
            var limit = 56;  // Integer | limit the result set to only include the specified number of entries (default to null)
            var offset = 56;  // Integer | start offset of the result set (useful for pagination) (default to null)
            var marker = marker_example;  // String |  (optional)  (default to null)
            var relationshipName = relationshipName_example;  // String | AtlasRelationshipType name (optional)  (default to null)
            var sortBy = sortBy_example;  // String | sort the result using this attribute name, default value is 'name' (optional)  (default to null)
            var sortOrder = sortOrder_example;  // String | sorting order (optional)  (default to null)

            try {
                apiInstance.relationSearch(limit, offset, marker, relationshipName, sortBy, sortOrder);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryRESTApi.relationSearch: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DiscoveryRESTApi();
$limit = 56; // Integer | limit the result set to only include the specified number of entries
$offset = 56; // Integer | start offset of the result set (useful for pagination)
$marker = marker_example; // String | 
$relationshipName = relationshipName_example; // String | AtlasRelationshipType name
$sortBy = sortBy_example; // String | sort the result using this attribute name, default value is 'name'
$sortOrder = sortOrder_example; // String | sorting order

try {
    $api_instance->relationSearch($limit, $offset, $marker, $relationshipName, $sortBy, $sortOrder);
} catch (Exception $e) {
    echo 'Exception when calling DiscoveryRESTApi->relationSearch: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DiscoveryRESTApi->new();
my $limit = 56; # Integer | limit the result set to only include the specified number of entries
my $offset = 56; # Integer | start offset of the result set (useful for pagination)
my $marker = marker_example; # String | 
my $relationshipName = relationshipName_example; # String | AtlasRelationshipType name
my $sortBy = sortBy_example; # String | sort the result using this attribute name, default value is 'name'
my $sortOrder = sortOrder_example; # String | sorting order

eval {
    $api_instance->relationSearch(limit => $limit, offset => $offset, marker => $marker, relationshipName => $relationshipName, sortBy => $sortBy, sortOrder => $sortOrder);
};
if ($@) {
    warn "Exception when calling DiscoveryRESTApi->relationSearch: $@\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.DiscoveryRESTApi()
limit = 56 # Integer | limit the result set to only include the specified number of entries (default to null)
offset = 56 # Integer | start offset of the result set (useful for pagination) (default to null)
marker = marker_example # String |  (optional) (default to null)
relationshipName = relationshipName_example # String | AtlasRelationshipType name (optional) (default to null)
sortBy = sortBy_example # String | sort the result using this attribute name, default value is 'name' (optional) (default to null)
sortOrder = sortOrder_example # String | sorting order (optional) (default to null)

try:
    api_instance.relation_search(limit, offset, marker=marker, relationshipName=relationshipName, sortBy=sortBy, sortOrder=sortOrder)
except ApiException as e:
    print("Exception when calling DiscoveryRESTApi->relationSearch: %s\n" % e)

extern crate DiscoveryRESTApi;

pub fn main() {
    let limit = 56; // Integer
    let offset = 56; // Integer
    let marker = marker_example; // String
    let relationshipName = relationshipName_example; // String
    let sortBy = sortBy_example; // String
    let sortOrder = sortOrder_example; // String

    let mut context = DiscoveryRESTApi::Context::default();
    let result = client.relationSearch(limit, offset, marker, relationshipName, sortBy, sortOrder, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        RelationshipSearchParameters relationshipSearchParameters = {"includeSubTypes":true,"limit":12345,"marker":"...","offset":12345,"relationshipFilters":{"attributeName":"...","attributeValue":"...","condition":"AND","criterion":[{},{}],"operator":"CONTAINS_ANY"},"relationshipName":"...","sortBy":"...","sortOrder":"ASCENDING"}; // RelationshipSearchParameters | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final RelationshipSearchParameters relationshipSearchParameters = new RelationshipSearchParameters(); // RelationshipSearchParameters | 

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

import org.openapitools.client.api.DiscoveryRESTApi;

public class DiscoveryRESTApiExample {
    public static void main(String[] args) {
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        RelationshipSearchParameters relationshipSearchParameters = {"includeSubTypes":true,"limit":12345,"marker":"...","offset":12345,"relationshipFilters":{"attributeName":"...","attributeValue":"...","condition":"AND","criterion":[{},{}],"operator":"CONTAINS_ANY"},"relationshipName":"...","sortBy":"...","sortOrder":"ASCENDING"}; // RelationshipSearchParameters | 

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

// Create an instance of the API class
DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];
RelationshipSearchParameters *relationshipSearchParameters = {"includeSubTypes":true,"limit":12345,"marker":"...","offset":12345,"relationshipFilters":{"attributeName":"...","attributeValue":"...","condition":"AND","criterion":[{},{}],"operator":"CONTAINS_ANY"},"relationshipName":"...","sortBy":"...","sortOrder":"ASCENDING"}; //  (optional)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.DiscoveryRESTApi()
var opts = {
  'relationshipSearchParameters': {"includeSubTypes":true,"limit":12345,"marker":"...","offset":12345,"relationshipFilters":{"attributeName":"...","attributeValue":"...","condition":"AND","criterion":[{},{}],"operator":"CONTAINS_ANY"},"relationshipName":"...","sortBy":"...","sortOrder":"ASCENDING"} // {RelationshipSearchParameters} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryRESTApi();
            var relationshipSearchParameters = new RelationshipSearchParameters(); // RelationshipSearchParameters |  (optional) 

            try {
                apiInstance.relationSearch2(relationshipSearchParameters);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryRESTApi.relationSearch2: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DiscoveryRESTApi();
$relationshipSearchParameters = {"includeSubTypes":true,"limit":12345,"marker":"...","offset":12345,"relationshipFilters":{"attributeName":"...","attributeValue":"...","condition":"AND","criterion":[{},{}],"operator":"CONTAINS_ANY"},"relationshipName":"...","sortBy":"...","sortOrder":"ASCENDING"}; // RelationshipSearchParameters | 

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

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

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

eval {
    $api_instance->relationSearch2(relationshipSearchParameters => $relationshipSearchParameters);
};
if ($@) {
    warn "Exception when calling DiscoveryRESTApi->relationSearch2: $@\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.DiscoveryRESTApi()
relationshipSearchParameters = {"includeSubTypes":true,"limit":12345,"marker":"...","offset":12345,"relationshipFilters":{"attributeName":"...","attributeValue":"...","condition":"AND","criterion":[{},{}],"operator":"CONTAINS_ANY"},"relationshipName":"...","sortBy":"...","sortOrder":"ASCENDING"} # RelationshipSearchParameters |  (optional)

try:
    api_instance.relation_search2(relationshipSearchParameters=relationshipSearchParameters)
except ApiException as e:
    print("Exception when calling DiscoveryRESTApi->relationSearch2: %s\n" % e)

extern crate DiscoveryRESTApi;

pub fn main() {
    let relationshipSearchParameters = {"includeSubTypes":true,"limit":12345,"marker":"...","offset":12345,"relationshipFilters":{"attributeName":"...","attributeValue":"...","condition":"AND","criterion":[{},{}],"operator":"CONTAINS_ANY"},"relationshipName":"...","sortBy":"...","sortOrder":"ASCENDING"}; // RelationshipSearchParameters

    let mut context = DiscoveryRESTApi::Context::default();
    let result = client.relationSearch2(relationshipSearchParameters, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        Boolean excludeDeletedEntities = true; // Boolean | exclude deleted entities from results
        Boolean getApproximateCount = true; // Boolean | calculate and return approximate count of total relationships
        Boolean includeClassificationAttributes = true; // Boolean | include classification attributes in result entities
        Integer limit = 56; // Integer | limit the result set to only include the specified number of entries
        Integer offset = 56; // Integer | start offset of the result set (useful for pagination)
        array[String] attributes = ; // array[String] | set of attributes to include in search result
        Boolean disableDefaultSorting = true; // Boolean | if true, disables default sorting by 'name' when sortByAttribute is not specified; allows unsorted results for better performance
        String guid = guid_example; // String | entity GUID
        String relation = relation_example; // String | relationship name or attribute name
        String sortBy = sortBy_example; // String | attribute name to sort results by (if not specified and disableDefaultSorting=false, defaults to 'name')
        String sortOrder = sortOrder_example; // String | sorting order (ASCENDING or DESCENDING)

        try {
            apiInstance.searchRelatedEntities(excludeDeletedEntities, getApproximateCount, includeClassificationAttributes, limit, offset, attributes, disableDefaultSorting, guid, relation, sortBy, sortOrder);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#searchRelatedEntities");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Boolean excludeDeletedEntities = new Boolean(); // Boolean | exclude deleted entities from results
final Boolean getApproximateCount = new Boolean(); // Boolean | calculate and return approximate count of total relationships
final Boolean includeClassificationAttributes = new Boolean(); // Boolean | include classification attributes in result entities
final Integer limit = new Integer(); // Integer | limit the result set to only include the specified number of entries
final Integer offset = new Integer(); // Integer | start offset of the result set (useful for pagination)
final array[String] attributes = new array[String](); // array[String] | set of attributes to include in search result
final Boolean disableDefaultSorting = new Boolean(); // Boolean | if true, disables default sorting by 'name' when sortByAttribute is not specified; allows unsorted results for better performance
final String guid = new String(); // String | entity GUID
final String relation = new String(); // String | relationship name or attribute name
final String sortBy = new String(); // String | attribute name to sort results by (if not specified and disableDefaultSorting=false, defaults to 'name')
final String sortOrder = new String(); // String | sorting order (ASCENDING or DESCENDING)

try {
    final result = await api_instance.searchRelatedEntities(excludeDeletedEntities, getApproximateCount, includeClassificationAttributes, limit, offset, attributes, disableDefaultSorting, guid, relation, sortBy, sortOrder);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->searchRelatedEntities: $e\n');
}

import org.openapitools.client.api.DiscoveryRESTApi;

public class DiscoveryRESTApiExample {
    public static void main(String[] args) {
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        Boolean excludeDeletedEntities = true; // Boolean | exclude deleted entities from results
        Boolean getApproximateCount = true; // Boolean | calculate and return approximate count of total relationships
        Boolean includeClassificationAttributes = true; // Boolean | include classification attributes in result entities
        Integer limit = 56; // Integer | limit the result set to only include the specified number of entries
        Integer offset = 56; // Integer | start offset of the result set (useful for pagination)
        array[String] attributes = ; // array[String] | set of attributes to include in search result
        Boolean disableDefaultSorting = true; // Boolean | if true, disables default sorting by 'name' when sortByAttribute is not specified; allows unsorted results for better performance
        String guid = guid_example; // String | entity GUID
        String relation = relation_example; // String | relationship name or attribute name
        String sortBy = sortBy_example; // String | attribute name to sort results by (if not specified and disableDefaultSorting=false, defaults to 'name')
        String sortOrder = sortOrder_example; // String | sorting order (ASCENDING or DESCENDING)

        try {
            apiInstance.searchRelatedEntities(excludeDeletedEntities, getApproximateCount, includeClassificationAttributes, limit, offset, attributes, disableDefaultSorting, guid, relation, sortBy, sortOrder);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#searchRelatedEntities");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];
Boolean *excludeDeletedEntities = true; // exclude deleted entities from results (default to null)
Boolean *getApproximateCount = true; // calculate and return approximate count of total relationships (default to null)
Boolean *includeClassificationAttributes = true; // include classification attributes in result entities (default to null)
Integer *limit = 56; // limit the result set to only include the specified number of entries (default to null)
Integer *offset = 56; // start offset of the result set (useful for pagination) (default to null)
array[String] *attributes = ; // set of attributes to include in search result (optional) (default to null)
Boolean *disableDefaultSorting = true; // if true, disables default sorting by 'name' when sortByAttribute is not specified; allows unsorted results for better performance (optional) (default to false)
String *guid = guid_example; // entity GUID (optional) (default to null)
String *relation = relation_example; // relationship name or attribute name (optional) (default to null)
String *sortBy = sortBy_example; // attribute name to sort results by (if not specified and disableDefaultSorting=false, defaults to 'name') (optional) (default to null)
String *sortOrder = sortOrder_example; // sorting order (ASCENDING or DESCENDING) (optional) (default to null)

[apiInstance searchRelatedEntitiesWith:excludeDeletedEntities
    getApproximateCount:getApproximateCount
    includeClassificationAttributes:includeClassificationAttributes
    limit:limit
    offset:offset
    attributes:attributes
    disableDefaultSorting:disableDefaultSorting
    guid:guid
    relation:relation
    sortBy:sortBy
    sortOrder:sortOrder
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.DiscoveryRESTApi()
var excludeDeletedEntities = true; // {Boolean} exclude deleted entities from results
var getApproximateCount = true; // {Boolean} calculate and return approximate count of total relationships
var includeClassificationAttributes = true; // {Boolean} include classification attributes in result entities
var limit = 56; // {Integer} limit the result set to only include the specified number of entries
var offset = 56; // {Integer} start offset of the result set (useful for pagination)
var opts = {
  'attributes': , // {array[String]} set of attributes to include in search result
  'disableDefaultSorting': true, // {Boolean} if true, disables default sorting by 'name' when sortByAttribute is not specified; allows unsorted results for better performance
  'guid': guid_example, // {String} entity GUID
  'relation': relation_example, // {String} relationship name or attribute name
  'sortBy': sortBy_example, // {String} attribute name to sort results by (if not specified and disableDefaultSorting=false, defaults to 'name')
  'sortOrder': sortOrder_example // {String} sorting order (ASCENDING or DESCENDING)
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.searchRelatedEntities(excludeDeletedEntities, getApproximateCount, includeClassificationAttributes, limit, offset, opts, callback);

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryRESTApi();
            var excludeDeletedEntities = true;  // Boolean | exclude deleted entities from results (default to null)
            var getApproximateCount = true;  // Boolean | calculate and return approximate count of total relationships (default to null)
            var includeClassificationAttributes = true;  // Boolean | include classification attributes in result entities (default to null)
            var limit = 56;  // Integer | limit the result set to only include the specified number of entries (default to null)
            var offset = 56;  // Integer | start offset of the result set (useful for pagination) (default to null)
            var attributes = new array[String](); // array[String] | set of attributes to include in search result (optional)  (default to null)
            var disableDefaultSorting = true;  // Boolean | if true, disables default sorting by 'name' when sortByAttribute is not specified; allows unsorted results for better performance (optional)  (default to false)
            var guid = guid_example;  // String | entity GUID (optional)  (default to null)
            var relation = relation_example;  // String | relationship name or attribute name (optional)  (default to null)
            var sortBy = sortBy_example;  // String | attribute name to sort results by (if not specified and disableDefaultSorting=false, defaults to 'name') (optional)  (default to null)
            var sortOrder = sortOrder_example;  // String | sorting order (ASCENDING or DESCENDING) (optional)  (default to null)

            try {
                apiInstance.searchRelatedEntities(excludeDeletedEntities, getApproximateCount, includeClassificationAttributes, limit, offset, attributes, disableDefaultSorting, guid, relation, sortBy, sortOrder);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryRESTApi.searchRelatedEntities: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DiscoveryRESTApi();
$excludeDeletedEntities = true; // Boolean | exclude deleted entities from results
$getApproximateCount = true; // Boolean | calculate and return approximate count of total relationships
$includeClassificationAttributes = true; // Boolean | include classification attributes in result entities
$limit = 56; // Integer | limit the result set to only include the specified number of entries
$offset = 56; // Integer | start offset of the result set (useful for pagination)
$attributes = ; // array[String] | set of attributes to include in search result
$disableDefaultSorting = true; // Boolean | if true, disables default sorting by 'name' when sortByAttribute is not specified; allows unsorted results for better performance
$guid = guid_example; // String | entity GUID
$relation = relation_example; // String | relationship name or attribute name
$sortBy = sortBy_example; // String | attribute name to sort results by (if not specified and disableDefaultSorting=false, defaults to 'name')
$sortOrder = sortOrder_example; // String | sorting order (ASCENDING or DESCENDING)

try {
    $api_instance->searchRelatedEntities($excludeDeletedEntities, $getApproximateCount, $includeClassificationAttributes, $limit, $offset, $attributes, $disableDefaultSorting, $guid, $relation, $sortBy, $sortOrder);
} catch (Exception $e) {
    echo 'Exception when calling DiscoveryRESTApi->searchRelatedEntities: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DiscoveryRESTApi->new();
my $excludeDeletedEntities = true; # Boolean | exclude deleted entities from results
my $getApproximateCount = true; # Boolean | calculate and return approximate count of total relationships
my $includeClassificationAttributes = true; # Boolean | include classification attributes in result entities
my $limit = 56; # Integer | limit the result set to only include the specified number of entries
my $offset = 56; # Integer | start offset of the result set (useful for pagination)
my $attributes = []; # array[String] | set of attributes to include in search result
my $disableDefaultSorting = true; # Boolean | if true, disables default sorting by 'name' when sortByAttribute is not specified; allows unsorted results for better performance
my $guid = guid_example; # String | entity GUID
my $relation = relation_example; # String | relationship name or attribute name
my $sortBy = sortBy_example; # String | attribute name to sort results by (if not specified and disableDefaultSorting=false, defaults to 'name')
my $sortOrder = sortOrder_example; # String | sorting order (ASCENDING or DESCENDING)

eval {
    $api_instance->searchRelatedEntities(excludeDeletedEntities => $excludeDeletedEntities, getApproximateCount => $getApproximateCount, includeClassificationAttributes => $includeClassificationAttributes, limit => $limit, offset => $offset, attributes => $attributes, disableDefaultSorting => $disableDefaultSorting, guid => $guid, relation => $relation, sortBy => $sortBy, sortOrder => $sortOrder);
};
if ($@) {
    warn "Exception when calling DiscoveryRESTApi->searchRelatedEntities: $@\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.DiscoveryRESTApi()
excludeDeletedEntities = true # Boolean | exclude deleted entities from results (default to null)
getApproximateCount = true # Boolean | calculate and return approximate count of total relationships (default to null)
includeClassificationAttributes = true # Boolean | include classification attributes in result entities (default to null)
limit = 56 # Integer | limit the result set to only include the specified number of entries (default to null)
offset = 56 # Integer | start offset of the result set (useful for pagination) (default to null)
attributes =  # array[String] | set of attributes to include in search result (optional) (default to null)
disableDefaultSorting = true # Boolean | if true, disables default sorting by 'name' when sortByAttribute is not specified; allows unsorted results for better performance (optional) (default to false)
guid = guid_example # String | entity GUID (optional) (default to null)
relation = relation_example # String | relationship name or attribute name (optional) (default to null)
sortBy = sortBy_example # String | attribute name to sort results by (if not specified and disableDefaultSorting=false, defaults to 'name') (optional) (default to null)
sortOrder = sortOrder_example # String | sorting order (ASCENDING or DESCENDING) (optional) (default to null)

try:
    api_instance.search_related_entities(excludeDeletedEntities, getApproximateCount, includeClassificationAttributes, limit, offset, attributes=attributes, disableDefaultSorting=disableDefaultSorting, guid=guid, relation=relation, sortBy=sortBy, sortOrder=sortOrder)
except ApiException as e:
    print("Exception when calling DiscoveryRESTApi->searchRelatedEntities: %s\n" % e)

extern crate DiscoveryRESTApi;

pub fn main() {
    let excludeDeletedEntities = true; // Boolean
    let getApproximateCount = true; // Boolean
    let includeClassificationAttributes = true; // Boolean
    let limit = 56; // Integer
    let offset = 56; // Integer
    let attributes = ; // array[String]
    let disableDefaultSorting = true; // Boolean
    let guid = guid_example; // String
    let relation = relation_example; // String
    let sortBy = sortBy_example; // String
    let sortOrder = sortOrder_example; // String

    let mut context = DiscoveryRESTApi::Context::default();
    let result = client.searchRelatedEntities(excludeDeletedEntities, getApproximateCount, includeClassificationAttributes, limit, offset, attributes, disableDefaultSorting, guid, relation, sortBy, sortOrder, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        Integer limit = 56; // Integer | limit the result set to only include the specified number of entries
        Integer offset = 56; // Integer | start offset of the result set (useful for pagination)
        String attrName = attrName_example; // String | Attribute name
        String attrValuePrefix = attrValuePrefix_example; // String | Attibute value to search on
        String typeName = typeName_example; // String | limit the result to only entities of specified type or its sub-types

        try {
            apiInstance.searchUsingAttribute(limit, offset, attrName, attrValuePrefix, typeName);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#searchUsingAttribute");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer limit = new Integer(); // Integer | limit the result set to only include the specified number of entries
final Integer offset = new Integer(); // Integer | start offset of the result set (useful for pagination)
final String attrName = new String(); // String | Attribute name
final String attrValuePrefix = new String(); // String | Attibute value to search on
final String typeName = new String(); // String | limit the result to only entities of specified type or its sub-types

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

import org.openapitools.client.api.DiscoveryRESTApi;

public class DiscoveryRESTApiExample {
    public static void main(String[] args) {
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        Integer limit = 56; // Integer | limit the result set to only include the specified number of entries
        Integer offset = 56; // Integer | start offset of the result set (useful for pagination)
        String attrName = attrName_example; // String | Attribute name
        String attrValuePrefix = attrValuePrefix_example; // String | Attibute value to search on
        String typeName = typeName_example; // String | limit the result to only entities of specified type or its sub-types

        try {
            apiInstance.searchUsingAttribute(limit, offset, attrName, attrValuePrefix, typeName);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#searchUsingAttribute");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];
Integer *limit = 56; // limit the result set to only include the specified number of entries (default to null)
Integer *offset = 56; // start offset of the result set (useful for pagination) (default to null)
String *attrName = attrName_example; // Attribute name (optional) (default to null)
String *attrValuePrefix = attrValuePrefix_example; // Attibute value to search on (optional) (default to null)
String *typeName = typeName_example; // limit the result to only entities of specified type or its sub-types (optional) (default to null)

[apiInstance searchUsingAttributeWith:limit
    offset:offset
    attrName:attrName
    attrValuePrefix:attrValuePrefix
    typeName:typeName
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.DiscoveryRESTApi()
var limit = 56; // {Integer} limit the result set to only include the specified number of entries
var offset = 56; // {Integer} start offset of the result set (useful for pagination)
var opts = {
  'attrName': attrName_example, // {String} Attribute name
  'attrValuePrefix': attrValuePrefix_example, // {String} Attibute value to search on
  'typeName': typeName_example // {String} limit the result to only entities of specified type or its sub-types
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryRESTApi();
            var limit = 56;  // Integer | limit the result set to only include the specified number of entries (default to null)
            var offset = 56;  // Integer | start offset of the result set (useful for pagination) (default to null)
            var attrName = attrName_example;  // String | Attribute name (optional)  (default to null)
            var attrValuePrefix = attrValuePrefix_example;  // String | Attibute value to search on (optional)  (default to null)
            var typeName = typeName_example;  // String | limit the result to only entities of specified type or its sub-types (optional)  (default to null)

            try {
                apiInstance.searchUsingAttribute(limit, offset, attrName, attrValuePrefix, typeName);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryRESTApi.searchUsingAttribute: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DiscoveryRESTApi();
$limit = 56; // Integer | limit the result set to only include the specified number of entries
$offset = 56; // Integer | start offset of the result set (useful for pagination)
$attrName = attrName_example; // String | Attribute name
$attrValuePrefix = attrValuePrefix_example; // String | Attibute value to search on
$typeName = typeName_example; // String | limit the result to only entities of specified type or its sub-types

try {
    $api_instance->searchUsingAttribute($limit, $offset, $attrName, $attrValuePrefix, $typeName);
} catch (Exception $e) {
    echo 'Exception when calling DiscoveryRESTApi->searchUsingAttribute: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DiscoveryRESTApi->new();
my $limit = 56; # Integer | limit the result set to only include the specified number of entries
my $offset = 56; # Integer | start offset of the result set (useful for pagination)
my $attrName = attrName_example; # String | Attribute name
my $attrValuePrefix = attrValuePrefix_example; # String | Attibute value to search on
my $typeName = typeName_example; # String | limit the result to only entities of specified type or its sub-types

eval {
    $api_instance->searchUsingAttribute(limit => $limit, offset => $offset, attrName => $attrName, attrValuePrefix => $attrValuePrefix, typeName => $typeName);
};
if ($@) {
    warn "Exception when calling DiscoveryRESTApi->searchUsingAttribute: $@\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.DiscoveryRESTApi()
limit = 56 # Integer | limit the result set to only include the specified number of entries (default to null)
offset = 56 # Integer | start offset of the result set (useful for pagination) (default to null)
attrName = attrName_example # String | Attribute name (optional) (default to null)
attrValuePrefix = attrValuePrefix_example # String | Attibute value to search on (optional) (default to null)
typeName = typeName_example # String | limit the result to only entities of specified type or its sub-types (optional) (default to null)

try:
    api_instance.search_using_attribute(limit, offset, attrName=attrName, attrValuePrefix=attrValuePrefix, typeName=typeName)
except ApiException as e:
    print("Exception when calling DiscoveryRESTApi->searchUsingAttribute: %s\n" % e)

extern crate DiscoveryRESTApi;

pub fn main() {
    let limit = 56; // Integer
    let offset = 56; // Integer
    let attrName = attrName_example; // String
    let attrValuePrefix = attrValuePrefix_example; // String
    let typeName = typeName_example; // String

    let mut context = DiscoveryRESTApi::Context::default();
    let result = client.searchUsingAttribute(limit, offset, attrName, attrValuePrefix, typeName, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        Boolean excludeDeletedEntities = true; // Boolean | 
        Integer limit = 56; // Integer | limit the result set to only include the specified number of entries
        Integer offset = 56; // Integer | start offset of the result set (useful for pagination)
        String classification = classification_example; // String | limit the result to only entities tagged with the given classification or or its sub-types
        String marker = marker_example; // String | 
        String query = query_example; // String | Fulltext query
        String sortBy = sortBy_example; // String | 
        String sortOrder = sortOrder_example; // String | 
        String typeName = typeName_example; // String | limit the result to only entities of specified type or its sub-types

        try {
            apiInstance.searchUsingBasic(excludeDeletedEntities, limit, offset, classification, marker, query, sortBy, sortOrder, typeName);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#searchUsingBasic");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Boolean excludeDeletedEntities = new Boolean(); // Boolean | 
final Integer limit = new Integer(); // Integer | limit the result set to only include the specified number of entries
final Integer offset = new Integer(); // Integer | start offset of the result set (useful for pagination)
final String classification = new String(); // String | limit the result to only entities tagged with the given classification or or its sub-types
final String marker = new String(); // String | 
final String query = new String(); // String | Fulltext query
final String sortBy = new String(); // String | 
final String sortOrder = new String(); // String | 
final String typeName = new String(); // String | limit the result to only entities of specified type or its sub-types

try {
    final result = await api_instance.searchUsingBasic(excludeDeletedEntities, limit, offset, classification, marker, query, sortBy, sortOrder, typeName);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->searchUsingBasic: $e\n');
}

import org.openapitools.client.api.DiscoveryRESTApi;

public class DiscoveryRESTApiExample {
    public static void main(String[] args) {
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        Boolean excludeDeletedEntities = true; // Boolean | 
        Integer limit = 56; // Integer | limit the result set to only include the specified number of entries
        Integer offset = 56; // Integer | start offset of the result set (useful for pagination)
        String classification = classification_example; // String | limit the result to only entities tagged with the given classification or or its sub-types
        String marker = marker_example; // String | 
        String query = query_example; // String | Fulltext query
        String sortBy = sortBy_example; // String | 
        String sortOrder = sortOrder_example; // String | 
        String typeName = typeName_example; // String | limit the result to only entities of specified type or its sub-types

        try {
            apiInstance.searchUsingBasic(excludeDeletedEntities, limit, offset, classification, marker, query, sortBy, sortOrder, typeName);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#searchUsingBasic");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];
Boolean *excludeDeletedEntities = true; //  (default to null)
Integer *limit = 56; // limit the result set to only include the specified number of entries (default to null)
Integer *offset = 56; // start offset of the result set (useful for pagination) (default to null)
String *classification = classification_example; // limit the result to only entities tagged with the given classification or or its sub-types (optional) (default to null)
String *marker = marker_example; //  (optional) (default to null)
String *query = query_example; // Fulltext query (optional) (default to null)
String *sortBy = sortBy_example; //  (optional) (default to null)
String *sortOrder = sortOrder_example; //  (optional) (default to null)
String *typeName = typeName_example; // limit the result to only entities of specified type or its sub-types (optional) (default to null)

[apiInstance searchUsingBasicWith:excludeDeletedEntities
    limit:limit
    offset:offset
    classification:classification
    marker:marker
    query:query
    sortBy:sortBy
    sortOrder:sortOrder
    typeName:typeName
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.DiscoveryRESTApi()
var excludeDeletedEntities = true; // {Boolean} 
var limit = 56; // {Integer} limit the result set to only include the specified number of entries
var offset = 56; // {Integer} start offset of the result set (useful for pagination)
var opts = {
  'classification': classification_example, // {String} limit the result to only entities tagged with the given classification or or its sub-types
  'marker': marker_example, // {String} 
  'query': query_example, // {String} Fulltext query
  'sortBy': sortBy_example, // {String} 
  'sortOrder': sortOrder_example, // {String} 
  'typeName': typeName_example // {String} limit the result to only entities of specified type or its sub-types
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryRESTApi();
            var excludeDeletedEntities = true;  // Boolean |  (default to null)
            var limit = 56;  // Integer | limit the result set to only include the specified number of entries (default to null)
            var offset = 56;  // Integer | start offset of the result set (useful for pagination) (default to null)
            var classification = classification_example;  // String | limit the result to only entities tagged with the given classification or or its sub-types (optional)  (default to null)
            var marker = marker_example;  // String |  (optional)  (default to null)
            var query = query_example;  // String | Fulltext query (optional)  (default to null)
            var sortBy = sortBy_example;  // String |  (optional)  (default to null)
            var sortOrder = sortOrder_example;  // String |  (optional)  (default to null)
            var typeName = typeName_example;  // String | limit the result to only entities of specified type or its sub-types (optional)  (default to null)

            try {
                apiInstance.searchUsingBasic(excludeDeletedEntities, limit, offset, classification, marker, query, sortBy, sortOrder, typeName);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryRESTApi.searchUsingBasic: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DiscoveryRESTApi();
$excludeDeletedEntities = true; // Boolean | 
$limit = 56; // Integer | limit the result set to only include the specified number of entries
$offset = 56; // Integer | start offset of the result set (useful for pagination)
$classification = classification_example; // String | limit the result to only entities tagged with the given classification or or its sub-types
$marker = marker_example; // String | 
$query = query_example; // String | Fulltext query
$sortBy = sortBy_example; // String | 
$sortOrder = sortOrder_example; // String | 
$typeName = typeName_example; // String | limit the result to only entities of specified type or its sub-types

try {
    $api_instance->searchUsingBasic($excludeDeletedEntities, $limit, $offset, $classification, $marker, $query, $sortBy, $sortOrder, $typeName);
} catch (Exception $e) {
    echo 'Exception when calling DiscoveryRESTApi->searchUsingBasic: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DiscoveryRESTApi->new();
my $excludeDeletedEntities = true; # Boolean | 
my $limit = 56; # Integer | limit the result set to only include the specified number of entries
my $offset = 56; # Integer | start offset of the result set (useful for pagination)
my $classification = classification_example; # String | limit the result to only entities tagged with the given classification or or its sub-types
my $marker = marker_example; # String | 
my $query = query_example; # String | Fulltext query
my $sortBy = sortBy_example; # String | 
my $sortOrder = sortOrder_example; # String | 
my $typeName = typeName_example; # String | limit the result to only entities of specified type or its sub-types

eval {
    $api_instance->searchUsingBasic(excludeDeletedEntities => $excludeDeletedEntities, limit => $limit, offset => $offset, classification => $classification, marker => $marker, query => $query, sortBy => $sortBy, sortOrder => $sortOrder, typeName => $typeName);
};
if ($@) {
    warn "Exception when calling DiscoveryRESTApi->searchUsingBasic: $@\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.DiscoveryRESTApi()
excludeDeletedEntities = true # Boolean |  (default to null)
limit = 56 # Integer | limit the result set to only include the specified number of entries (default to null)
offset = 56 # Integer | start offset of the result set (useful for pagination) (default to null)
classification = classification_example # String | limit the result to only entities tagged with the given classification or or its sub-types (optional) (default to null)
marker = marker_example # String |  (optional) (default to null)
query = query_example # String | Fulltext query (optional) (default to null)
sortBy = sortBy_example # String |  (optional) (default to null)
sortOrder = sortOrder_example # String |  (optional) (default to null)
typeName = typeName_example # String | limit the result to only entities of specified type or its sub-types (optional) (default to null)

try:
    api_instance.search_using_basic(excludeDeletedEntities, limit, offset, classification=classification, marker=marker, query=query, sortBy=sortBy, sortOrder=sortOrder, typeName=typeName)
except ApiException as e:
    print("Exception when calling DiscoveryRESTApi->searchUsingBasic: %s\n" % e)

extern crate DiscoveryRESTApi;

pub fn main() {
    let excludeDeletedEntities = true; // Boolean
    let limit = 56; // Integer
    let offset = 56; // Integer
    let classification = classification_example; // String
    let marker = marker_example; // String
    let query = query_example; // String
    let sortBy = sortBy_example; // String
    let sortOrder = sortOrder_example; // String
    let typeName = typeName_example; // String

    let mut context = DiscoveryRESTApi::Context::default();
    let result = client.searchUsingBasic(excludeDeletedEntities, limit, offset, classification, marker, query, sortBy, sortOrder, typeName, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        Integer limit = 56; // Integer | limit the result set to only include the specified number of entries
        Integer offset = 56; // Integer | start offset of the result set (useful for pagination)
        String classification = classification_example; // String | limit the result to only entities tagged with the given classification or or its sub-types
        String query = query_example; // String | DSL query
        String typeName = typeName_example; // String | limit the result to only entities of specified type or its sub-types

        try {
            apiInstance.searchUsingDSL(limit, offset, classification, query, typeName);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#searchUsingDSL");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer limit = new Integer(); // Integer | limit the result set to only include the specified number of entries
final Integer offset = new Integer(); // Integer | start offset of the result set (useful for pagination)
final String classification = new String(); // String | limit the result to only entities tagged with the given classification or or its sub-types
final String query = new String(); // String | DSL query
final String typeName = new String(); // String | limit the result to only entities of specified type or its sub-types

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

import org.openapitools.client.api.DiscoveryRESTApi;

public class DiscoveryRESTApiExample {
    public static void main(String[] args) {
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        Integer limit = 56; // Integer | limit the result set to only include the specified number of entries
        Integer offset = 56; // Integer | start offset of the result set (useful for pagination)
        String classification = classification_example; // String | limit the result to only entities tagged with the given classification or or its sub-types
        String query = query_example; // String | DSL query
        String typeName = typeName_example; // String | limit the result to only entities of specified type or its sub-types

        try {
            apiInstance.searchUsingDSL(limit, offset, classification, query, typeName);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#searchUsingDSL");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];
Integer *limit = 56; // limit the result set to only include the specified number of entries (default to null)
Integer *offset = 56; // start offset of the result set (useful for pagination) (default to null)
String *classification = classification_example; // limit the result to only entities tagged with the given classification or or its sub-types (optional) (default to null)
String *query = query_example; // DSL query (optional) (default to null)
String *typeName = typeName_example; // limit the result to only entities of specified type or its sub-types (optional) (default to null)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.DiscoveryRESTApi()
var limit = 56; // {Integer} limit the result set to only include the specified number of entries
var offset = 56; // {Integer} start offset of the result set (useful for pagination)
var opts = {
  'classification': classification_example, // {String} limit the result to only entities tagged with the given classification or or its sub-types
  'query': query_example, // {String} DSL query
  'typeName': typeName_example // {String} limit the result to only entities of specified type or its sub-types
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryRESTApi();
            var limit = 56;  // Integer | limit the result set to only include the specified number of entries (default to null)
            var offset = 56;  // Integer | start offset of the result set (useful for pagination) (default to null)
            var classification = classification_example;  // String | limit the result to only entities tagged with the given classification or or its sub-types (optional)  (default to null)
            var query = query_example;  // String | DSL query (optional)  (default to null)
            var typeName = typeName_example;  // String | limit the result to only entities of specified type or its sub-types (optional)  (default to null)

            try {
                apiInstance.searchUsingDSL(limit, offset, classification, query, typeName);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryRESTApi.searchUsingDSL: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DiscoveryRESTApi();
$limit = 56; // Integer | limit the result set to only include the specified number of entries
$offset = 56; // Integer | start offset of the result set (useful for pagination)
$classification = classification_example; // String | limit the result to only entities tagged with the given classification or or its sub-types
$query = query_example; // String | DSL query
$typeName = typeName_example; // String | limit the result to only entities of specified type or its sub-types

try {
    $api_instance->searchUsingDSL($limit, $offset, $classification, $query, $typeName);
} catch (Exception $e) {
    echo 'Exception when calling DiscoveryRESTApi->searchUsingDSL: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DiscoveryRESTApi->new();
my $limit = 56; # Integer | limit the result set to only include the specified number of entries
my $offset = 56; # Integer | start offset of the result set (useful for pagination)
my $classification = classification_example; # String | limit the result to only entities tagged with the given classification or or its sub-types
my $query = query_example; # String | DSL query
my $typeName = typeName_example; # String | limit the result to only entities of specified type or its sub-types

eval {
    $api_instance->searchUsingDSL(limit => $limit, offset => $offset, classification => $classification, query => $query, typeName => $typeName);
};
if ($@) {
    warn "Exception when calling DiscoveryRESTApi->searchUsingDSL: $@\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.DiscoveryRESTApi()
limit = 56 # Integer | limit the result set to only include the specified number of entries (default to null)
offset = 56 # Integer | start offset of the result set (useful for pagination) (default to null)
classification = classification_example # String | limit the result to only entities tagged with the given classification or or its sub-types (optional) (default to null)
query = query_example # String | DSL query (optional) (default to null)
typeName = typeName_example # String | limit the result to only entities of specified type or its sub-types (optional) (default to null)

try:
    api_instance.search_using_dsl(limit, offset, classification=classification, query=query, typeName=typeName)
except ApiException as e:
    print("Exception when calling DiscoveryRESTApi->searchUsingDSL: %s\n" % e)

extern crate DiscoveryRESTApi;

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

    let mut context = DiscoveryRESTApi::Context::default();
    let result = client.searchUsingDSL(limit, offset, classification, query, typeName, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        Boolean excludeDeletedEntities = true; // Boolean | 
        Integer limit = 56; // Integer | limit the result set to only include the specified number of entries
        Integer offset = 56; // Integer | start offset of the result set (useful for pagination)
        String query = query_example; // String | Fulltext query

        try {
            apiInstance.searchUsingFullText(excludeDeletedEntities, limit, offset, query);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#searchUsingFullText");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Boolean excludeDeletedEntities = new Boolean(); // Boolean | 
final Integer limit = new Integer(); // Integer | limit the result set to only include the specified number of entries
final Integer offset = new Integer(); // Integer | start offset of the result set (useful for pagination)
final String query = new String(); // String | Fulltext query

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

import org.openapitools.client.api.DiscoveryRESTApi;

public class DiscoveryRESTApiExample {
    public static void main(String[] args) {
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        Boolean excludeDeletedEntities = true; // Boolean | 
        Integer limit = 56; // Integer | limit the result set to only include the specified number of entries
        Integer offset = 56; // Integer | start offset of the result set (useful for pagination)
        String query = query_example; // String | Fulltext query

        try {
            apiInstance.searchUsingFullText(excludeDeletedEntities, limit, offset, query);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#searchUsingFullText");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];
Boolean *excludeDeletedEntities = true; //  (default to null)
Integer *limit = 56; // limit the result set to only include the specified number of entries (default to null)
Integer *offset = 56; // start offset of the result set (useful for pagination) (default to null)
String *query = query_example; // Fulltext query (optional) (default to null)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.DiscoveryRESTApi()
var excludeDeletedEntities = true; // {Boolean} 
var limit = 56; // {Integer} limit the result set to only include the specified number of entries
var offset = 56; // {Integer} start offset of the result set (useful for pagination)
var opts = {
  'query': query_example // {String} Fulltext query
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryRESTApi();
            var excludeDeletedEntities = true;  // Boolean |  (default to null)
            var limit = 56;  // Integer | limit the result set to only include the specified number of entries (default to null)
            var offset = 56;  // Integer | start offset of the result set (useful for pagination) (default to null)
            var query = query_example;  // String | Fulltext query (optional)  (default to null)

            try {
                apiInstance.searchUsingFullText(excludeDeletedEntities, limit, offset, query);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryRESTApi.searchUsingFullText: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DiscoveryRESTApi();
$excludeDeletedEntities = true; // Boolean | 
$limit = 56; // Integer | limit the result set to only include the specified number of entries
$offset = 56; // Integer | start offset of the result set (useful for pagination)
$query = query_example; // String | Fulltext query

try {
    $api_instance->searchUsingFullText($excludeDeletedEntities, $limit, $offset, $query);
} catch (Exception $e) {
    echo 'Exception when calling DiscoveryRESTApi->searchUsingFullText: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DiscoveryRESTApi->new();
my $excludeDeletedEntities = true; # Boolean | 
my $limit = 56; # Integer | limit the result set to only include the specified number of entries
my $offset = 56; # Integer | start offset of the result set (useful for pagination)
my $query = query_example; # String | Fulltext query

eval {
    $api_instance->searchUsingFullText(excludeDeletedEntities => $excludeDeletedEntities, limit => $limit, offset => $offset, query => $query);
};
if ($@) {
    warn "Exception when calling DiscoveryRESTApi->searchUsingFullText: $@\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.DiscoveryRESTApi()
excludeDeletedEntities = true # Boolean |  (default to null)
limit = 56 # Integer | limit the result set to only include the specified number of entries (default to null)
offset = 56 # Integer | start offset of the result set (useful for pagination) (default to null)
query = query_example # String | Fulltext query (optional) (default to null)

try:
    api_instance.search_using_full_text(excludeDeletedEntities, limit, offset, query=query)
except ApiException as e:
    print("Exception when calling DiscoveryRESTApi->searchUsingFullText: %s\n" % e)

extern crate DiscoveryRESTApi;

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

    let mut context = DiscoveryRESTApi::Context::default();
    let result = client.searchUsingFullText(excludeDeletedEntities, limit, offset, query, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        SearchParameters searchParameters = {"attributes":["...","..."],"classification":"...","entityFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"CONTAINS_ALL"},"excludeDeletedEntities":true,"excludeHeaderAttributes":true,"includeClassificationAttributes":true,"includeSubClassifications":true,"includeSubTypes":true,"limit":12345,"marker":"...","offset":12345,"query":"...","relationshipFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"IS_EMPTY"},"relationshipName":"...","sortBy":"...","sortOrder":"ASCENDING","tagFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"CONTAINS"},"termName":"...","typeName":"..."}; // SearchParameters | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final SearchParameters searchParameters = new SearchParameters(); // SearchParameters | 

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

import org.openapitools.client.api.DiscoveryRESTApi;

public class DiscoveryRESTApiExample {
    public static void main(String[] args) {
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        SearchParameters searchParameters = {"attributes":["...","..."],"classification":"...","entityFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"CONTAINS_ALL"},"excludeDeletedEntities":true,"excludeHeaderAttributes":true,"includeClassificationAttributes":true,"includeSubClassifications":true,"includeSubTypes":true,"limit":12345,"marker":"...","offset":12345,"query":"...","relationshipFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"IS_EMPTY"},"relationshipName":"...","sortBy":"...","sortOrder":"ASCENDING","tagFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"CONTAINS"},"termName":"...","typeName":"..."}; // SearchParameters | 

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

// Create an instance of the API class
DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];
SearchParameters *searchParameters = {"attributes":["...","..."],"classification":"...","entityFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"CONTAINS_ALL"},"excludeDeletedEntities":true,"excludeHeaderAttributes":true,"includeClassificationAttributes":true,"includeSubClassifications":true,"includeSubTypes":true,"limit":12345,"marker":"...","offset":12345,"query":"...","relationshipFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"IS_EMPTY"},"relationshipName":"...","sortBy":"...","sortOrder":"ASCENDING","tagFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"CONTAINS"},"termName":"...","typeName":"..."}; //  (optional)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.DiscoveryRESTApi()
var opts = {
  'searchParameters': {"attributes":["...","..."],"classification":"...","entityFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"CONTAINS_ALL"},"excludeDeletedEntities":true,"excludeHeaderAttributes":true,"includeClassificationAttributes":true,"includeSubClassifications":true,"includeSubTypes":true,"limit":12345,"marker":"...","offset":12345,"query":"...","relationshipFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"IS_EMPTY"},"relationshipName":"...","sortBy":"...","sortOrder":"ASCENDING","tagFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"CONTAINS"},"termName":"...","typeName":"..."} // {SearchParameters} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryRESTApi();
            var searchParameters = new SearchParameters(); // SearchParameters |  (optional) 

            try {
                apiInstance.searchWithParameters(searchParameters);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryRESTApi.searchWithParameters: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DiscoveryRESTApi();
$searchParameters = {"attributes":["...","..."],"classification":"...","entityFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"CONTAINS_ALL"},"excludeDeletedEntities":true,"excludeHeaderAttributes":true,"includeClassificationAttributes":true,"includeSubClassifications":true,"includeSubTypes":true,"limit":12345,"marker":"...","offset":12345,"query":"...","relationshipFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"IS_EMPTY"},"relationshipName":"...","sortBy":"...","sortOrder":"ASCENDING","tagFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"CONTAINS"},"termName":"...","typeName":"..."}; // SearchParameters | 

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

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

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

eval {
    $api_instance->searchWithParameters(searchParameters => $searchParameters);
};
if ($@) {
    warn "Exception when calling DiscoveryRESTApi->searchWithParameters: $@\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.DiscoveryRESTApi()
searchParameters = {"attributes":["...","..."],"classification":"...","entityFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"CONTAINS_ALL"},"excludeDeletedEntities":true,"excludeHeaderAttributes":true,"includeClassificationAttributes":true,"includeSubClassifications":true,"includeSubTypes":true,"limit":12345,"marker":"...","offset":12345,"query":"...","relationshipFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"IS_EMPTY"},"relationshipName":"...","sortBy":"...","sortOrder":"ASCENDING","tagFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"CONTAINS"},"termName":"...","typeName":"..."} # SearchParameters |  (optional)

try:
    api_instance.search_with_parameters(searchParameters=searchParameters)
except ApiException as e:
    print("Exception when calling DiscoveryRESTApi->searchWithParameters: %s\n" % e)

extern crate DiscoveryRESTApi;

pub fn main() {
    let searchParameters = {"attributes":["...","..."],"classification":"...","entityFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"CONTAINS_ALL"},"excludeDeletedEntities":true,"excludeHeaderAttributes":true,"includeClassificationAttributes":true,"includeSubClassifications":true,"includeSubTypes":true,"limit":12345,"marker":"...","offset":12345,"query":"...","relationshipFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"IS_EMPTY"},"relationshipName":"...","sortBy":"...","sortOrder":"ASCENDING","tagFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"CONTAINS"},"termName":"...","typeName":"..."}; // SearchParameters

    let mut context = DiscoveryRESTApi::Context::default();
    let result = client.searchWithParameters(searchParameters, &context).wait();

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

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

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

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

        // Create an instance of the API class
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        AtlasUserSavedSearch atlasUserSavedSearch = {"name":"...","ownerName":"...","searchParameters":{"attributes":["...","..."],"classification":"...","entityFilters":{"attributeName":"...","attributeValue":"...","condition":"AND","criterion":[{},{}],"operator":"ENDS_WITH"},"excludeDeletedEntities":true,"excludeHeaderAttributes":true,"includeClassificationAttributes":true,"includeSubClassifications":true,"includeSubTypes":true,"limit":12345,"marker":"...","offset":12345,"query":"...","relationshipFilters":{"attributeName":"...","attributeValue":"...","condition":"AND","criterion":[{},{}],"operator":"IS_EMPTY"},"relationshipName":"...","sortBy":"...","sortOrder":"DESCENDING","tagFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"EQ"},"termName":"...","typeName":"..."},"searchType":"ADVANCED","uiParameters":"...","guid":"..."}; // AtlasUserSavedSearch | 

        try {
            AtlasUserSavedSearch result = apiInstance.updateSavedSearch(atlasUserSavedSearch);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#updateSavedSearch");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final AtlasUserSavedSearch atlasUserSavedSearch = new AtlasUserSavedSearch(); // AtlasUserSavedSearch | 

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

import org.openapitools.client.api.DiscoveryRESTApi;

public class DiscoveryRESTApiExample {
    public static void main(String[] args) {
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        AtlasUserSavedSearch atlasUserSavedSearch = {"name":"...","ownerName":"...","searchParameters":{"attributes":["...","..."],"classification":"...","entityFilters":{"attributeName":"...","attributeValue":"...","condition":"AND","criterion":[{},{}],"operator":"ENDS_WITH"},"excludeDeletedEntities":true,"excludeHeaderAttributes":true,"includeClassificationAttributes":true,"includeSubClassifications":true,"includeSubTypes":true,"limit":12345,"marker":"...","offset":12345,"query":"...","relationshipFilters":{"attributeName":"...","attributeValue":"...","condition":"AND","criterion":[{},{}],"operator":"IS_EMPTY"},"relationshipName":"...","sortBy":"...","sortOrder":"DESCENDING","tagFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"EQ"},"termName":"...","typeName":"..."},"searchType":"ADVANCED","uiParameters":"...","guid":"..."}; // AtlasUserSavedSearch | 

        try {
            AtlasUserSavedSearch result = apiInstance.updateSavedSearch(atlasUserSavedSearch);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#updateSavedSearch");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];
AtlasUserSavedSearch *atlasUserSavedSearch = {"name":"...","ownerName":"...","searchParameters":{"attributes":["...","..."],"classification":"...","entityFilters":{"attributeName":"...","attributeValue":"...","condition":"AND","criterion":[{},{}],"operator":"ENDS_WITH"},"excludeDeletedEntities":true,"excludeHeaderAttributes":true,"includeClassificationAttributes":true,"includeSubClassifications":true,"includeSubTypes":true,"limit":12345,"marker":"...","offset":12345,"query":"...","relationshipFilters":{"attributeName":"...","attributeValue":"...","condition":"AND","criterion":[{},{}],"operator":"IS_EMPTY"},"relationshipName":"...","sortBy":"...","sortOrder":"DESCENDING","tagFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"EQ"},"termName":"...","typeName":"..."},"searchType":"ADVANCED","uiParameters":"...","guid":"..."}; //  (optional)

[apiInstance updateSavedSearchWith:atlasUserSavedSearch
              completionHandler: ^(AtlasUserSavedSearch output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.DiscoveryRESTApi()
var opts = {
  'atlasUserSavedSearch': {"name":"...","ownerName":"...","searchParameters":{"attributes":["...","..."],"classification":"...","entityFilters":{"attributeName":"...","attributeValue":"...","condition":"AND","criterion":[{},{}],"operator":"ENDS_WITH"},"excludeDeletedEntities":true,"excludeHeaderAttributes":true,"includeClassificationAttributes":true,"includeSubClassifications":true,"includeSubTypes":true,"limit":12345,"marker":"...","offset":12345,"query":"...","relationshipFilters":{"attributeName":"...","attributeValue":"...","condition":"AND","criterion":[{},{}],"operator":"IS_EMPTY"},"relationshipName":"...","sortBy":"...","sortOrder":"DESCENDING","tagFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"EQ"},"termName":"...","typeName":"..."},"searchType":"ADVANCED","uiParameters":"...","guid":"..."} // {AtlasUserSavedSearch} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DiscoveryRESTApi();
            var atlasUserSavedSearch = new AtlasUserSavedSearch(); // AtlasUserSavedSearch |  (optional) 

            try {
                AtlasUserSavedSearch result = apiInstance.updateSavedSearch(atlasUserSavedSearch);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DiscoveryRESTApi.updateSavedSearch: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DiscoveryRESTApi();
$atlasUserSavedSearch = {"name":"...","ownerName":"...","searchParameters":{"attributes":["...","..."],"classification":"...","entityFilters":{"attributeName":"...","attributeValue":"...","condition":"AND","criterion":[{},{}],"operator":"ENDS_WITH"},"excludeDeletedEntities":true,"excludeHeaderAttributes":true,"includeClassificationAttributes":true,"includeSubClassifications":true,"includeSubTypes":true,"limit":12345,"marker":"...","offset":12345,"query":"...","relationshipFilters":{"attributeName":"...","attributeValue":"...","condition":"AND","criterion":[{},{}],"operator":"IS_EMPTY"},"relationshipName":"...","sortBy":"...","sortOrder":"DESCENDING","tagFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"EQ"},"termName":"...","typeName":"..."},"searchType":"ADVANCED","uiParameters":"...","guid":"..."}; // AtlasUserSavedSearch | 

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

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

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

eval {
    my $result = $api_instance->updateSavedSearch(atlasUserSavedSearch => $atlasUserSavedSearch);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DiscoveryRESTApi->updateSavedSearch: $@\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.DiscoveryRESTApi()
atlasUserSavedSearch = {"name":"...","ownerName":"...","searchParameters":{"attributes":["...","..."],"classification":"...","entityFilters":{"attributeName":"...","attributeValue":"...","condition":"AND","criterion":[{},{}],"operator":"ENDS_WITH"},"excludeDeletedEntities":true,"excludeHeaderAttributes":true,"includeClassificationAttributes":true,"includeSubClassifications":true,"includeSubTypes":true,"limit":12345,"marker":"...","offset":12345,"query":"...","relationshipFilters":{"attributeName":"...","attributeValue":"...","condition":"AND","criterion":[{},{}],"operator":"IS_EMPTY"},"relationshipName":"...","sortBy":"...","sortOrder":"DESCENDING","tagFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"EQ"},"termName":"...","typeName":"..."},"searchType":"ADVANCED","uiParameters":"...","guid":"..."} # AtlasUserSavedSearch |  (optional)

try:
    api_response = api_instance.update_saved_search(atlasUserSavedSearch=atlasUserSavedSearch)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DiscoveryRESTApi->updateSavedSearch: %s\n" % e)

extern crate DiscoveryRESTApi;

pub fn main() {
    let atlasUserSavedSearch = {"name":"...","ownerName":"...","searchParameters":{"attributes":["...","..."],"classification":"...","entityFilters":{"attributeName":"...","attributeValue":"...","condition":"AND","criterion":[{},{}],"operator":"ENDS_WITH"},"excludeDeletedEntities":true,"excludeHeaderAttributes":true,"includeClassificationAttributes":true,"includeSubClassifications":true,"includeSubTypes":true,"limit":12345,"marker":"...","offset":12345,"query":"...","relationshipFilters":{"attributeName":"...","attributeValue":"...","condition":"AND","criterion":[{},{}],"operator":"IS_EMPTY"},"relationshipName":"...","sortBy":"...","sortOrder":"DESCENDING","tagFilters":{"attributeName":"...","attributeValue":"...","condition":"OR","criterion":[{},{}],"operator":"EQ"},"termName":"...","typeName":"..."},"searchType":"ADVANCED","uiParameters":"...","guid":"..."}; // AtlasUserSavedSearch

    let mut context = DiscoveryRESTApi::Context::default();
    let result = client.updateSavedSearch(atlasUserSavedSearch, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        ClassificationAssociateRequest classificationAssociateRequest = {"classification":{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},"entitiesUniqueAttributes":[{"property1":{},"property2":{}},{"property1":{},"property2":{}}],"entityGuids":["...","..."],"entityTypeName":"..."}; // ClassificationAssociateRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ClassificationAssociateRequest classificationAssociateRequest = new ClassificationAssociateRequest(); // ClassificationAssociateRequest | 

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        ClassificationAssociateRequest classificationAssociateRequest = {"classification":{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},"entitiesUniqueAttributes":[{"property1":{},"property2":{}},{"property1":{},"property2":{}}],"entityGuids":["...","..."],"entityTypeName":"..."}; // ClassificationAssociateRequest | 

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

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
ClassificationAssociateRequest *classificationAssociateRequest = {"classification":{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},"entitiesUniqueAttributes":[{"property1":{},"property2":{}},{"property1":{},"property2":{}}],"entityGuids":["...","..."],"entityTypeName":"..."}; //  (optional)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var opts = {
  'classificationAssociateRequest': {"classification":{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},"entitiesUniqueAttributes":[{"property1":{},"property2":{}},{"property1":{},"property2":{}}],"entityGuids":["...","..."],"entityTypeName":"..."} // {ClassificationAssociateRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var classificationAssociateRequest = new ClassificationAssociateRequest(); // ClassificationAssociateRequest |  (optional) 

            try {
                apiInstance.addClassification(classificationAssociateRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.addClassification: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$classificationAssociateRequest = {"classification":{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},"entitiesUniqueAttributes":[{"property1":{},"property2":{}},{"property1":{},"property2":{}}],"entityGuids":["...","..."],"entityTypeName":"..."}; // ClassificationAssociateRequest | 

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

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

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

eval {
    $api_instance->addClassification(classificationAssociateRequest => $classificationAssociateRequest);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->addClassification: $@\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.EntityRESTApi()
classificationAssociateRequest = {"classification":{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},"entitiesUniqueAttributes":[{"property1":{},"property2":{}},{"property1":{},"property2":{}}],"entityGuids":["...","..."],"entityTypeName":"..."} # ClassificationAssociateRequest |  (optional)

try:
    api_instance.add_classification(classificationAssociateRequest=classificationAssociateRequest)
except ApiException as e:
    print("Exception when calling EntityRESTApi->addClassification: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let classificationAssociateRequest = {"classification":{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},"entitiesUniqueAttributes":[{"property1":{},"property2":{}},{"property1":{},"property2":{}}],"entityGuids":["...","..."],"entityTypeName":"..."}; // ClassificationAssociateRequest

    let mut context = EntityRESTApi::Context::default();
    let result = client.addClassification(classificationAssociateRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | globally unique identifier for the entity
        array[AtlasClassification] atlasClassification = [{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}]; // array[AtlasClassification] | 

        try {
            apiInstance.addClassifications(guid, atlasClassification);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#addClassifications");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String guid = new String(); // String | globally unique identifier for the entity
final array[AtlasClassification] atlasClassification = new array[AtlasClassification](); // array[AtlasClassification] | 

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | globally unique identifier for the entity
        array[AtlasClassification] atlasClassification = [{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}]; // array[AtlasClassification] | 

        try {
            apiInstance.addClassifications(guid, atlasClassification);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#addClassifications");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
String *guid = guid_example; // globally unique identifier for the entity (default to null)
array[AtlasClassification] *atlasClassification = [{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}]; //  (optional)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var guid = guid_example; // {String} globally unique identifier for the entity
var opts = {
  'atlasClassification': [{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}] // {array[AtlasClassification]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var guid = guid_example;  // String | globally unique identifier for the entity (default to null)
            var atlasClassification = new array[AtlasClassification](); // array[AtlasClassification] |  (optional) 

            try {
                apiInstance.addClassifications(guid, atlasClassification);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.addClassifications: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$guid = guid_example; // String | globally unique identifier for the entity
$atlasClassification = [{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}]; // array[AtlasClassification] | 

try {
    $api_instance->addClassifications($guid, $atlasClassification);
} catch (Exception $e) {
    echo 'Exception when calling EntityRESTApi->addClassifications: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $guid = guid_example; # String | globally unique identifier for the entity
my $atlasClassification = [WWW::OPenAPIClient::Object::array[AtlasClassification]->new()]; # array[AtlasClassification] | 

eval {
    $api_instance->addClassifications(guid => $guid, atlasClassification => $atlasClassification);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->addClassifications: $@\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.EntityRESTApi()
guid = guid_example # String | globally unique identifier for the entity (default to null)
atlasClassification = [{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}] # array[AtlasClassification] |  (optional)

try:
    api_instance.add_classifications(guid, atlasClassification=atlasClassification)
except ApiException as e:
    print("Exception when calling EntityRESTApi->addClassifications: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let guid = guid_example; // String
    let atlasClassification = [{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}]; // array[AtlasClassification]

    let mut context = EntityRESTApi::Context::default();
    let result = client.addClassifications(guid, atlasClassification, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | 
        array[AtlasClassification] atlasClassification = [{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}]; // array[AtlasClassification] | 

        try {
            apiInstance.addClassificationsByUniqueAttribute(typeName, atlasClassification);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#addClassificationsByUniqueAttribute");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String typeName = new String(); // String | 
final array[AtlasClassification] atlasClassification = new array[AtlasClassification](); // array[AtlasClassification] | 

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | 
        array[AtlasClassification] atlasClassification = [{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}]; // array[AtlasClassification] | 

        try {
            apiInstance.addClassificationsByUniqueAttribute(typeName, atlasClassification);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#addClassificationsByUniqueAttribute");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
String *typeName = typeName_example; //  (default to null)
array[AtlasClassification] *atlasClassification = [{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}]; //  (optional)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var typeName = typeName_example; // {String} 
var opts = {
  'atlasClassification': [{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}] // {array[AtlasClassification]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var typeName = typeName_example;  // String |  (default to null)
            var atlasClassification = new array[AtlasClassification](); // array[AtlasClassification] |  (optional) 

            try {
                apiInstance.addClassificationsByUniqueAttribute(typeName, atlasClassification);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.addClassificationsByUniqueAttribute: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$typeName = typeName_example; // String | 
$atlasClassification = [{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}]; // array[AtlasClassification] | 

try {
    $api_instance->addClassificationsByUniqueAttribute($typeName, $atlasClassification);
} catch (Exception $e) {
    echo 'Exception when calling EntityRESTApi->addClassificationsByUniqueAttribute: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $typeName = typeName_example; # String | 
my $atlasClassification = [WWW::OPenAPIClient::Object::array[AtlasClassification]->new()]; # array[AtlasClassification] | 

eval {
    $api_instance->addClassificationsByUniqueAttribute(typeName => $typeName, atlasClassification => $atlasClassification);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->addClassificationsByUniqueAttribute: $@\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.EntityRESTApi()
typeName = typeName_example # String |  (default to null)
atlasClassification = [{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}] # array[AtlasClassification] |  (optional)

try:
    api_instance.add_classifications_by_unique_attribute(typeName, atlasClassification=atlasClassification)
except ApiException as e:
    print("Exception when calling EntityRESTApi->addClassificationsByUniqueAttribute: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let typeName = typeName_example; // String
    let atlasClassification = [{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}]; // array[AtlasClassification]

    let mut context = EntityRESTApi::Context::default();
    let result = client.addClassificationsByUniqueAttribute(typeName, atlasClassification, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | - Unique entity identifier
        array[String] string = ; // array[String] | 

        try {
            apiInstance.addLabels(guid, string);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#addLabels");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String guid = new String(); // String | - Unique entity identifier
final array[String] string = new array[String](); // array[String] | 

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | - Unique entity identifier
        array[String] string = ; // array[String] | 

        try {
            apiInstance.addLabels(guid, string);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#addLabels");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
String *guid = guid_example; // - Unique entity identifier (default to null)
array[String] *string = ; //  (optional)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var guid = guid_example; // {String} - Unique entity identifier
var opts = {
  'string':  // {array[String]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var guid = guid_example;  // String | - Unique entity identifier (default to null)
            var string = new array[String](); // array[String] |  (optional) 

            try {
                apiInstance.addLabels(guid, string);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.addLabels: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$guid = guid_example; // String | - Unique entity identifier
$string = ; // array[String] | 

try {
    $api_instance->addLabels($guid, $string);
} catch (Exception $e) {
    echo 'Exception when calling EntityRESTApi->addLabels: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $guid = guid_example; # String | - Unique entity identifier
my $string = [WWW::OPenAPIClient::Object::array[String]->new()]; # array[String] | 

eval {
    $api_instance->addLabels(guid => $guid, string => $string);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->addLabels: $@\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.EntityRESTApi()
guid = guid_example # String | - Unique entity identifier (default to null)
string =  # array[String] |  (optional)

try:
    api_instance.add_labels(guid, string=string)
except ApiException as e:
    print("Exception when calling EntityRESTApi->addLabels: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let guid = guid_example; // String
    let string = ; // array[String]

    let mut context = EntityRESTApi::Context::default();
    let result = client.addLabels(guid, string, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | 
        array[String] string = ; // array[String] | 

        try {
            apiInstance.addLabels2(typeName, string);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#addLabels2");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String typeName = new String(); // String | 
final array[String] string = new array[String](); // array[String] | 

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | 
        array[String] string = ; // array[String] | 

        try {
            apiInstance.addLabels2(typeName, string);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#addLabels2");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
String *typeName = typeName_example; //  (default to null)
array[String] *string = ; //  (optional)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var typeName = typeName_example; // {String} 
var opts = {
  'string':  // {array[String]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var typeName = typeName_example;  // String |  (default to null)
            var string = new array[String](); // array[String] |  (optional) 

            try {
                apiInstance.addLabels2(typeName, string);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.addLabels2: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$typeName = typeName_example; // String | 
$string = ; // array[String] | 

try {
    $api_instance->addLabels2($typeName, $string);
} catch (Exception $e) {
    echo 'Exception when calling EntityRESTApi->addLabels2: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $typeName = typeName_example; # String | 
my $string = [WWW::OPenAPIClient::Object::array[String]->new()]; # array[String] | 

eval {
    $api_instance->addLabels2(typeName => $typeName, string => $string);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->addLabels2: $@\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.EntityRESTApi()
typeName = typeName_example # String |  (default to null)
string =  # array[String] |  (optional)

try:
    api_instance.add_labels2(typeName, string=string)
except ApiException as e:
    print("Exception when calling EntityRESTApi->addLabels2: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let typeName = typeName_example; // String
    let string = ; // array[String]

    let mut context = EntityRESTApi::Context::default();
    let result = client.addLabels2(typeName, string, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | 
        Boolean isOverwrite = true; // Boolean | 
        map[String, Object] requestBody = Object; // map[String, Object] | 

        try {
            apiInstance.addOrUpdateBusinessAttributes(guid, isOverwrite, requestBody);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#addOrUpdateBusinessAttributes");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String guid = new String(); // String | 
final Boolean isOverwrite = new Boolean(); // Boolean | 
final map[String, Object] requestBody = new map[String, Object](); // map[String, Object] | 

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | 
        Boolean isOverwrite = true; // Boolean | 
        map[String, Object] requestBody = Object; // map[String, Object] | 

        try {
            apiInstance.addOrUpdateBusinessAttributes(guid, isOverwrite, requestBody);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#addOrUpdateBusinessAttributes");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
String *guid = guid_example; //  (default to null)
Boolean *isOverwrite = true; //  (optional) (default to false)
map[String, Object] *requestBody = Object; //  (optional)

[apiInstance addOrUpdateBusinessAttributesWith:guid
    isOverwrite:isOverwrite
    requestBody:requestBody
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var guid = guid_example; // {String} 
var opts = {
  'isOverwrite': true, // {Boolean} 
  'requestBody': Object // {map[String, Object]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var guid = guid_example;  // String |  (default to null)
            var isOverwrite = true;  // Boolean |  (optional)  (default to false)
            var requestBody = new map[String, Object](); // map[String, Object] |  (optional) 

            try {
                apiInstance.addOrUpdateBusinessAttributes(guid, isOverwrite, requestBody);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.addOrUpdateBusinessAttributes: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$guid = guid_example; // String | 
$isOverwrite = true; // Boolean | 
$requestBody = Object; // map[String, Object] | 

try {
    $api_instance->addOrUpdateBusinessAttributes($guid, $isOverwrite, $requestBody);
} catch (Exception $e) {
    echo 'Exception when calling EntityRESTApi->addOrUpdateBusinessAttributes: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $guid = guid_example; # String | 
my $isOverwrite = true; # Boolean | 
my $requestBody = WWW::OPenAPIClient::Object::map[String, Object]->new(); # map[String, Object] | 

eval {
    $api_instance->addOrUpdateBusinessAttributes(guid => $guid, isOverwrite => $isOverwrite, requestBody => $requestBody);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->addOrUpdateBusinessAttributes: $@\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.EntityRESTApi()
guid = guid_example # String |  (default to null)
isOverwrite = true # Boolean |  (optional) (default to false)
requestBody = Object # map[String, Object] |  (optional)

try:
    api_instance.add_or_update_business_attributes(guid, isOverwrite=isOverwrite, requestBody=requestBody)
except ApiException as e:
    print("Exception when calling EntityRESTApi->addOrUpdateBusinessAttributes: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let guid = guid_example; // String
    let isOverwrite = true; // Boolean
    let requestBody = Object; // map[String, Object]

    let mut context = EntityRESTApi::Context::default();
    let result = client.addOrUpdateBusinessAttributes(guid, isOverwrite, requestBody, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        String bmName = bmName_example; // String | 
        String guid = guid_example; // String | 
        map[String, Object] requestBody = Object; // map[String, Object] | 

        try {
            apiInstance.addOrUpdateBusinessAttributes2(bmName, guid, requestBody);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#addOrUpdateBusinessAttributes2");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String bmName = new String(); // String | 
final String guid = new String(); // String | 
final map[String, Object] requestBody = new map[String, Object](); // map[String, Object] | 

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String bmName = bmName_example; // String | 
        String guid = guid_example; // String | 
        map[String, Object] requestBody = Object; // map[String, Object] | 

        try {
            apiInstance.addOrUpdateBusinessAttributes2(bmName, guid, requestBody);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#addOrUpdateBusinessAttributes2");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
String *bmName = bmName_example; //  (default to null)
String *guid = guid_example; //  (default to null)
map[String, Object] *requestBody = Object; //  (optional)

[apiInstance addOrUpdateBusinessAttributes2With:bmName
    guid:guid
    requestBody:requestBody
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var bmName = bmName_example; // {String} 
var guid = guid_example; // {String} 
var opts = {
  'requestBody': Object // {map[String, Object]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var bmName = bmName_example;  // String |  (default to null)
            var guid = guid_example;  // String |  (default to null)
            var requestBody = new map[String, Object](); // map[String, Object] |  (optional) 

            try {
                apiInstance.addOrUpdateBusinessAttributes2(bmName, guid, requestBody);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.addOrUpdateBusinessAttributes2: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$bmName = bmName_example; // String | 
$guid = guid_example; // String | 
$requestBody = Object; // map[String, Object] | 

try {
    $api_instance->addOrUpdateBusinessAttributes2($bmName, $guid, $requestBody);
} catch (Exception $e) {
    echo 'Exception when calling EntityRESTApi->addOrUpdateBusinessAttributes2: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $bmName = bmName_example; # String | 
my $guid = guid_example; # String | 
my $requestBody = WWW::OPenAPIClient::Object::map[String, Object]->new(); # map[String, Object] | 

eval {
    $api_instance->addOrUpdateBusinessAttributes2(bmName => $bmName, guid => $guid, requestBody => $requestBody);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->addOrUpdateBusinessAttributes2: $@\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.EntityRESTApi()
bmName = bmName_example # String |  (default to null)
guid = guid_example # String |  (default to null)
requestBody = Object # map[String, Object] |  (optional)

try:
    api_instance.add_or_update_business_attributes2(bmName, guid, requestBody=requestBody)
except ApiException as e:
    print("Exception when calling EntityRESTApi->addOrUpdateBusinessAttributes2: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let bmName = bmName_example; // String
    let guid = guid_example; // String
    let requestBody = Object; // map[String, Object]

    let mut context = EntityRESTApi::Context::default();
    let result = client.addOrUpdateBusinessAttributes2(bmName, guid, requestBody, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        AtlasEntityWithExtInfo atlasEntityWithExtInfo = {"entity":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"IMPORTED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"referredEntities":{"property1":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DISCOVERED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"property2":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"IMPORTED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"IMPORTED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"DELETED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."}}}; // AtlasEntityWithExtInfo | 

        try {
            EntityMutationResponse result = apiInstance.createOrUpdate(atlasEntityWithExtInfo);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#createOrUpdate");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final AtlasEntityWithExtInfo atlasEntityWithExtInfo = new AtlasEntityWithExtInfo(); // AtlasEntityWithExtInfo | 

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        AtlasEntityWithExtInfo atlasEntityWithExtInfo = {"entity":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"IMPORTED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"referredEntities":{"property1":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DISCOVERED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"property2":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"IMPORTED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"IMPORTED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"DELETED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."}}}; // AtlasEntityWithExtInfo | 

        try {
            EntityMutationResponse result = apiInstance.createOrUpdate(atlasEntityWithExtInfo);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#createOrUpdate");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
AtlasEntityWithExtInfo *atlasEntityWithExtInfo = {"entity":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"IMPORTED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"referredEntities":{"property1":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DISCOVERED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"property2":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"IMPORTED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"IMPORTED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"DELETED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."}}}; //  (optional)

[apiInstance createOrUpdateWith:atlasEntityWithExtInfo
              completionHandler: ^(EntityMutationResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var opts = {
  'atlasEntityWithExtInfo': {"entity":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"IMPORTED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"referredEntities":{"property1":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DISCOVERED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"property2":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"IMPORTED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"IMPORTED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"DELETED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."}}} // {AtlasEntityWithExtInfo} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var atlasEntityWithExtInfo = new AtlasEntityWithExtInfo(); // AtlasEntityWithExtInfo |  (optional) 

            try {
                EntityMutationResponse result = apiInstance.createOrUpdate(atlasEntityWithExtInfo);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.createOrUpdate: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$atlasEntityWithExtInfo = {"entity":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"IMPORTED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"referredEntities":{"property1":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DISCOVERED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"property2":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"IMPORTED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"IMPORTED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"DELETED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."}}}; // AtlasEntityWithExtInfo | 

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

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

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

eval {
    my $result = $api_instance->createOrUpdate(atlasEntityWithExtInfo => $atlasEntityWithExtInfo);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->createOrUpdate: $@\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.EntityRESTApi()
atlasEntityWithExtInfo = {"entity":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"IMPORTED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"referredEntities":{"property1":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DISCOVERED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"property2":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"IMPORTED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"IMPORTED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"DELETED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."}}} # AtlasEntityWithExtInfo |  (optional)

try:
    api_response = api_instance.create_or_update(atlasEntityWithExtInfo=atlasEntityWithExtInfo)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EntityRESTApi->createOrUpdate: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let atlasEntityWithExtInfo = {"entity":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"IMPORTED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"referredEntities":{"property1":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DISCOVERED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"property2":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"IMPORTED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"IMPORTED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"DELETED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."}}}; // AtlasEntityWithExtInfo

    let mut context = EntityRESTApi::Context::default();
    let result = client.createOrUpdate(atlasEntityWithExtInfo, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        AtlasEntitiesWithExtInfo atlasEntitiesWithExtInfo = {"entities":[{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"VALIDATED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"PURGED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"PROPOSED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DISCOVERED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"DELETED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"referredEntities":{"property1":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"IMPORTED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"PURGED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"property2":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DISCOVERED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."}}}; // AtlasEntitiesWithExtInfo | 

        try {
            EntityMutationResponse result = apiInstance.createOrUpdate2(atlasEntitiesWithExtInfo);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#createOrUpdate2");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final AtlasEntitiesWithExtInfo atlasEntitiesWithExtInfo = new AtlasEntitiesWithExtInfo(); // AtlasEntitiesWithExtInfo | 

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        AtlasEntitiesWithExtInfo atlasEntitiesWithExtInfo = {"entities":[{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"VALIDATED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"PURGED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"PROPOSED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DISCOVERED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"DELETED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"referredEntities":{"property1":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"IMPORTED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"PURGED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"property2":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DISCOVERED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."}}}; // AtlasEntitiesWithExtInfo | 

        try {
            EntityMutationResponse result = apiInstance.createOrUpdate2(atlasEntitiesWithExtInfo);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#createOrUpdate2");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
AtlasEntitiesWithExtInfo *atlasEntitiesWithExtInfo = {"entities":[{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"VALIDATED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"PURGED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"PROPOSED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DISCOVERED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"DELETED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"referredEntities":{"property1":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"IMPORTED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"PURGED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"property2":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DISCOVERED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."}}}; //  (optional)

[apiInstance createOrUpdate2With:atlasEntitiesWithExtInfo
              completionHandler: ^(EntityMutationResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var opts = {
  'atlasEntitiesWithExtInfo': {"entities":[{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"VALIDATED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"PURGED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"PROPOSED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DISCOVERED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"DELETED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"referredEntities":{"property1":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"IMPORTED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"PURGED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"property2":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DISCOVERED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."}}} // {AtlasEntitiesWithExtInfo} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var atlasEntitiesWithExtInfo = new AtlasEntitiesWithExtInfo(); // AtlasEntitiesWithExtInfo |  (optional) 

            try {
                EntityMutationResponse result = apiInstance.createOrUpdate2(atlasEntitiesWithExtInfo);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.createOrUpdate2: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$atlasEntitiesWithExtInfo = {"entities":[{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"VALIDATED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"PURGED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"PROPOSED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DISCOVERED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"DELETED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"referredEntities":{"property1":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"IMPORTED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"PURGED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"property2":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DISCOVERED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."}}}; // AtlasEntitiesWithExtInfo | 

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

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

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

eval {
    my $result = $api_instance->createOrUpdate2(atlasEntitiesWithExtInfo => $atlasEntitiesWithExtInfo);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->createOrUpdate2: $@\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.EntityRESTApi()
atlasEntitiesWithExtInfo = {"entities":[{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"VALIDATED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"PURGED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"PROPOSED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DISCOVERED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"DELETED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"referredEntities":{"property1":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"IMPORTED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"PURGED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"property2":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DISCOVERED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."}}} # AtlasEntitiesWithExtInfo |  (optional)

try:
    api_response = api_instance.create_or_update2(atlasEntitiesWithExtInfo=atlasEntitiesWithExtInfo)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EntityRESTApi->createOrUpdate2: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let atlasEntitiesWithExtInfo = {"entities":[{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"VALIDATED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"PURGED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"PROPOSED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DISCOVERED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"DELETED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"referredEntities":{"property1":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"IMPORTED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"PURGED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"property2":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DISCOVERED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."}}}; // AtlasEntitiesWithExtInfo

    let mut context = EntityRESTApi::Context::default();
    let result = client.createOrUpdate2(atlasEntitiesWithExtInfo, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | GUID for the entity

        try {
            EntityMutationResponse result = apiInstance.deleteByGuid(guid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#deleteByGuid");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String guid = new String(); // String | GUID for the entity

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | GUID for the entity

        try {
            EntityMutationResponse result = apiInstance.deleteByGuid(guid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#deleteByGuid");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
String *guid = guid_example; // GUID for the entity (default to null)

[apiInstance deleteByGuidWith:guid
              completionHandler: ^(EntityMutationResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var guid = guid_example; // {String} GUID for the entity

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var guid = guid_example;  // String | GUID for the entity (default to null)

            try {
                EntityMutationResponse result = apiInstance.deleteByGuid(guid);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.deleteByGuid: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$guid = guid_example; // String | GUID for the entity

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $guid = guid_example; # String | GUID for the entity

eval {
    my $result = $api_instance->deleteByGuid(guid => $guid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->deleteByGuid: $@\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.EntityRESTApi()
guid = guid_example # String | GUID for the entity (default to null)

try:
    api_response = api_instance.delete_by_guid(guid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EntityRESTApi->deleteByGuid: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let guid = guid_example; // String

    let mut context = EntityRESTApi::Context::default();
    let result = client.deleteByGuid(guid, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        array[String] guid = ; // array[String] | 

        try {
            EntityMutationResponse result = apiInstance.deleteByGuids(guid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#deleteByGuids");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[String] guid = new array[String](); // array[String] | 

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        array[String] guid = ; // array[String] | 

        try {
            EntityMutationResponse result = apiInstance.deleteByGuids(guid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#deleteByGuids");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
array[String] *guid = ; //  (optional) (default to null)

[apiInstance deleteByGuidsWith:guid
              completionHandler: ^(EntityMutationResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var opts = {
  'guid':  // {array[String]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var guid = new array[String](); // array[String] |  (optional)  (default to null)

            try {
                EntityMutationResponse result = apiInstance.deleteByGuids(guid);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.deleteByGuids: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$guid = ; // array[String] | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $guid = []; # array[String] | 

eval {
    my $result = $api_instance->deleteByGuids(guid => $guid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->deleteByGuids: $@\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.EntityRESTApi()
guid =  # array[String] |  (optional) (default to null)

try:
    api_response = api_instance.delete_by_guids(guid=guid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EntityRESTApi->deleteByGuids: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let guid = ; // array[String]

    let mut context = EntityRESTApi::Context::default();
    let result = client.deleteByGuids(guid, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | - entity type to be deleted

        try {
            EntityMutationResponse result = apiInstance.deleteByUniqueAttribute(typeName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#deleteByUniqueAttribute");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String typeName = new String(); // String | - entity type to be deleted

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | - entity type to be deleted

        try {
            EntityMutationResponse result = apiInstance.deleteByUniqueAttribute(typeName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#deleteByUniqueAttribute");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
String *typeName = typeName_example; // - entity type to be deleted (default to null)

[apiInstance deleteByUniqueAttributeWith:typeName
              completionHandler: ^(EntityMutationResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var typeName = typeName_example; // {String} - entity type to be deleted

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var typeName = typeName_example;  // String | - entity type to be deleted (default to null)

            try {
                EntityMutationResponse result = apiInstance.deleteByUniqueAttribute(typeName);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.deleteByUniqueAttribute: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$typeName = typeName_example; // String | - entity type to be deleted

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $typeName = typeName_example; # String | - entity type to be deleted

eval {
    my $result = $api_instance->deleteByUniqueAttribute(typeName => $typeName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->deleteByUniqueAttribute: $@\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.EntityRESTApi()
typeName = typeName_example # String | - entity type to be deleted (default to null)

try:
    api_response = api_instance.delete_by_unique_attribute(typeName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EntityRESTApi->deleteByUniqueAttribute: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let typeName = typeName_example; // String

    let mut context = EntityRESTApi::Context::default();
    let result = client.deleteByUniqueAttribute(typeName, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        String classificationName = classificationName_example; // String | name of the classifcation
        String guid = guid_example; // String | globally unique identifier for the entity
        String associatedEntityGuid = associatedEntityGuid_example; // String | 

        try {
            apiInstance.deleteClassification(classificationName, guid, associatedEntityGuid);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#deleteClassification");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String classificationName = new String(); // String | name of the classifcation
final String guid = new String(); // String | globally unique identifier for the entity
final String associatedEntityGuid = new String(); // String | 

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String classificationName = classificationName_example; // String | name of the classifcation
        String guid = guid_example; // String | globally unique identifier for the entity
        String associatedEntityGuid = associatedEntityGuid_example; // String | 

        try {
            apiInstance.deleteClassification(classificationName, guid, associatedEntityGuid);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#deleteClassification");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
String *classificationName = classificationName_example; // name of the classifcation (default to null)
String *guid = guid_example; // globally unique identifier for the entity (default to null)
String *associatedEntityGuid = associatedEntityGuid_example; //  (optional) (default to null)

[apiInstance deleteClassificationWith:classificationName
    guid:guid
    associatedEntityGuid:associatedEntityGuid
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var classificationName = classificationName_example; // {String} name of the classifcation
var guid = guid_example; // {String} globally unique identifier for the entity
var opts = {
  'associatedEntityGuid': associatedEntityGuid_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var classificationName = classificationName_example;  // String | name of the classifcation (default to null)
            var guid = guid_example;  // String | globally unique identifier for the entity (default to null)
            var associatedEntityGuid = associatedEntityGuid_example;  // String |  (optional)  (default to null)

            try {
                apiInstance.deleteClassification(classificationName, guid, associatedEntityGuid);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.deleteClassification: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$classificationName = classificationName_example; // String | name of the classifcation
$guid = guid_example; // String | globally unique identifier for the entity
$associatedEntityGuid = associatedEntityGuid_example; // String | 

try {
    $api_instance->deleteClassification($classificationName, $guid, $associatedEntityGuid);
} catch (Exception $e) {
    echo 'Exception when calling EntityRESTApi->deleteClassification: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $classificationName = classificationName_example; # String | name of the classifcation
my $guid = guid_example; # String | globally unique identifier for the entity
my $associatedEntityGuid = associatedEntityGuid_example; # String | 

eval {
    $api_instance->deleteClassification(classificationName => $classificationName, guid => $guid, associatedEntityGuid => $associatedEntityGuid);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->deleteClassification: $@\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.EntityRESTApi()
classificationName = classificationName_example # String | name of the classifcation (default to null)
guid = guid_example # String | globally unique identifier for the entity (default to null)
associatedEntityGuid = associatedEntityGuid_example # String |  (optional) (default to null)

try:
    api_instance.delete_classification(classificationName, guid, associatedEntityGuid=associatedEntityGuid)
except ApiException as e:
    print("Exception when calling EntityRESTApi->deleteClassification: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let classificationName = classificationName_example; // String
    let guid = guid_example; // String
    let associatedEntityGuid = associatedEntityGuid_example; // String

    let mut context = EntityRESTApi::Context::default();
    let result = client.deleteClassification(classificationName, guid, associatedEntityGuid, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        String classificationName = classificationName_example; // String | name of the classification
        String typeName = typeName_example; // String | 

        try {
            apiInstance.deleteClassificationByUniqueAttribute(classificationName, typeName);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#deleteClassificationByUniqueAttribute");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String classificationName = new String(); // String | name of the classification
final String typeName = new String(); // String | 

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String classificationName = classificationName_example; // String | name of the classification
        String typeName = typeName_example; // String | 

        try {
            apiInstance.deleteClassificationByUniqueAttribute(classificationName, typeName);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#deleteClassificationByUniqueAttribute");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
String *classificationName = classificationName_example; // name of the classification (default to null)
String *typeName = typeName_example; //  (default to null)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var classificationName = classificationName_example; // {String} name of the classification
var typeName = typeName_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var classificationName = classificationName_example;  // String | name of the classification (default to null)
            var typeName = typeName_example;  // String |  (default to null)

            try {
                apiInstance.deleteClassificationByUniqueAttribute(classificationName, typeName);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.deleteClassificationByUniqueAttribute: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$classificationName = classificationName_example; // String | name of the classification
$typeName = typeName_example; // String | 

try {
    $api_instance->deleteClassificationByUniqueAttribute($classificationName, $typeName);
} catch (Exception $e) {
    echo 'Exception when calling EntityRESTApi->deleteClassificationByUniqueAttribute: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $classificationName = classificationName_example; # String | name of the classification
my $typeName = typeName_example; # String | 

eval {
    $api_instance->deleteClassificationByUniqueAttribute(classificationName => $classificationName, typeName => $typeName);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->deleteClassificationByUniqueAttribute: $@\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.EntityRESTApi()
classificationName = classificationName_example # String | name of the classification (default to null)
typeName = typeName_example # String |  (default to null)

try:
    api_instance.delete_classification_by_unique_attribute(classificationName, typeName)
except ApiException as e:
    print("Exception when calling EntityRESTApi->deleteClassificationByUniqueAttribute: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let classificationName = classificationName_example; // String
    let typeName = typeName_example; // String

    let mut context = EntityRESTApi::Context::default();
    let result = client.deleteClassificationByUniqueAttribute(classificationName, typeName, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | 
        String auditAction = auditAction_example; // String | 
        Integer count = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String sortBy = sortBy_example; // String | 
        String sortOrder = sortOrder_example; // String | 
        String startKey = startKey_example; // String | 

        try {
            array[EntityAuditEventV2] result = apiInstance.getAuditEvents(guid, auditAction, count, offset, sortBy, sortOrder, startKey);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#getAuditEvents");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String guid = new String(); // String | 
final String auditAction = new String(); // String | 
final Integer count = new Integer(); // Integer | 
final Integer offset = new Integer(); // Integer | 
final String sortBy = new String(); // String | 
final String sortOrder = new String(); // String | 
final String startKey = new String(); // String | 

try {
    final result = await api_instance.getAuditEvents(guid, auditAction, count, offset, sortBy, sortOrder, startKey);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getAuditEvents: $e\n');
}

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | 
        String auditAction = auditAction_example; // String | 
        Integer count = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String sortBy = sortBy_example; // String | 
        String sortOrder = sortOrder_example; // String | 
        String startKey = startKey_example; // String | 

        try {
            array[EntityAuditEventV2] result = apiInstance.getAuditEvents(guid, auditAction, count, offset, sortBy, sortOrder, startKey);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#getAuditEvents");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
String *guid = guid_example; //  (default to null)
String *auditAction = auditAction_example; //  (optional) (default to null)
Integer *count = 56; //  (optional) (default to null)
Integer *offset = 56; //  (optional) (default to null)
String *sortBy = sortBy_example; //  (optional) (default to null)
String *sortOrder = sortOrder_example; //  (optional) (default to null)
String *startKey = startKey_example; //  (optional) (default to null)

[apiInstance getAuditEventsWith:guid
    auditAction:auditAction
    count:count
    offset:offset
    sortBy:sortBy
    sortOrder:sortOrder
    startKey:startKey
              completionHandler: ^(array[EntityAuditEventV2] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var guid = guid_example; // {String} 
var opts = {
  'auditAction': auditAction_example, // {String} 
  'count': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'sortBy': sortBy_example, // {String} 
  'sortOrder': sortOrder_example, // {String} 
  'startKey': startKey_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var guid = guid_example;  // String |  (default to null)
            var auditAction = auditAction_example;  // String |  (optional)  (default to null)
            var count = 56;  // Integer |  (optional)  (default to null)
            var offset = 56;  // Integer |  (optional)  (default to null)
            var sortBy = sortBy_example;  // String |  (optional)  (default to null)
            var sortOrder = sortOrder_example;  // String |  (optional)  (default to null)
            var startKey = startKey_example;  // String |  (optional)  (default to null)

            try {
                array[EntityAuditEventV2] result = apiInstance.getAuditEvents(guid, auditAction, count, offset, sortBy, sortOrder, startKey);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.getAuditEvents: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$guid = guid_example; // String | 
$auditAction = auditAction_example; // String | 
$count = 56; // Integer | 
$offset = 56; // Integer | 
$sortBy = sortBy_example; // String | 
$sortOrder = sortOrder_example; // String | 
$startKey = startKey_example; // String | 

try {
    $result = $api_instance->getAuditEvents($guid, $auditAction, $count, $offset, $sortBy, $sortOrder, $startKey);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling EntityRESTApi->getAuditEvents: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $guid = guid_example; # String | 
my $auditAction = auditAction_example; # String | 
my $count = 56; # Integer | 
my $offset = 56; # Integer | 
my $sortBy = sortBy_example; # String | 
my $sortOrder = sortOrder_example; # String | 
my $startKey = startKey_example; # String | 

eval {
    my $result = $api_instance->getAuditEvents(guid => $guid, auditAction => $auditAction, count => $count, offset => $offset, sortBy => $sortBy, sortOrder => $sortOrder, startKey => $startKey);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->getAuditEvents: $@\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.EntityRESTApi()
guid = guid_example # String |  (default to null)
auditAction = auditAction_example # String |  (optional) (default to null)
count = 56 # Integer |  (optional) (default to null)
offset = 56 # Integer |  (optional) (default to null)
sortBy = sortBy_example # String |  (optional) (default to null)
sortOrder = sortOrder_example # String |  (optional) (default to null)
startKey = startKey_example # String |  (optional) (default to null)

try:
    api_response = api_instance.get_audit_events(guid, auditAction=auditAction, count=count, offset=offset, sortBy=sortBy, sortOrder=sortOrder, startKey=startKey)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EntityRESTApi->getAuditEvents: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let guid = guid_example; // String
    let auditAction = auditAction_example; // String
    let count = 56; // Integer
    let offset = 56; // Integer
    let sortBy = sortBy_example; // String
    let sortOrder = sortOrder_example; // String
    let startKey = startKey_example; // String

    let mut context = EntityRESTApi::Context::default();
    let result = client.getAuditEvents(guid, auditAction, count, offset, sortBy, sortOrder, startKey, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        array[String] guid = ; // array[String] | 
        Boolean ignoreRelationships = true; // Boolean | 
        Boolean minExtInfo = true; // Boolean | 

        try {
            AtlasEntitiesWithExtInfo result = apiInstance.getByGuids(guid, ignoreRelationships, minExtInfo);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#getByGuids");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[String] guid = new array[String](); // array[String] | 
final Boolean ignoreRelationships = new Boolean(); // Boolean | 
final Boolean minExtInfo = new Boolean(); // Boolean | 

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        array[String] guid = ; // array[String] | 
        Boolean ignoreRelationships = true; // Boolean | 
        Boolean minExtInfo = true; // Boolean | 

        try {
            AtlasEntitiesWithExtInfo result = apiInstance.getByGuids(guid, ignoreRelationships, minExtInfo);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#getByGuids");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
array[String] *guid = ; //  (optional) (default to null)
Boolean *ignoreRelationships = true; //  (optional) (default to false)
Boolean *minExtInfo = true; //  (optional) (default to false)

[apiInstance getByGuidsWith:guid
    ignoreRelationships:ignoreRelationships
    minExtInfo:minExtInfo
              completionHandler: ^(AtlasEntitiesWithExtInfo output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var opts = {
  'guid': , // {array[String]} 
  'ignoreRelationships': true, // {Boolean} 
  'minExtInfo': true // {Boolean} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var guid = new array[String](); // array[String] |  (optional)  (default to null)
            var ignoreRelationships = true;  // Boolean |  (optional)  (default to false)
            var minExtInfo = true;  // Boolean |  (optional)  (default to false)

            try {
                AtlasEntitiesWithExtInfo result = apiInstance.getByGuids(guid, ignoreRelationships, minExtInfo);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.getByGuids: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$guid = ; // array[String] | 
$ignoreRelationships = true; // Boolean | 
$minExtInfo = true; // Boolean | 

try {
    $result = $api_instance->getByGuids($guid, $ignoreRelationships, $minExtInfo);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling EntityRESTApi->getByGuids: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $guid = []; # array[String] | 
my $ignoreRelationships = true; # Boolean | 
my $minExtInfo = true; # Boolean | 

eval {
    my $result = $api_instance->getByGuids(guid => $guid, ignoreRelationships => $ignoreRelationships, minExtInfo => $minExtInfo);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->getByGuids: $@\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.EntityRESTApi()
guid =  # array[String] |  (optional) (default to null)
ignoreRelationships = true # Boolean |  (optional) (default to false)
minExtInfo = true # Boolean |  (optional) (default to false)

try:
    api_response = api_instance.get_by_guids(guid=guid, ignoreRelationships=ignoreRelationships, minExtInfo=minExtInfo)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EntityRESTApi->getByGuids: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let guid = ; // array[String]
    let ignoreRelationships = true; // Boolean
    let minExtInfo = true; // Boolean

    let mut context = EntityRESTApi::Context::default();
    let result = client.getByGuids(guid, ignoreRelationships, minExtInfo, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | GUID for the entity
        Boolean ignoreRelationships = true; // Boolean | 
        Boolean minExtInfo = true; // Boolean | 

        try {
            AtlasEntityWithExtInfo result = apiInstance.getById(guid, ignoreRelationships, minExtInfo);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#getById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String guid = new String(); // String | GUID for the entity
final Boolean ignoreRelationships = new Boolean(); // Boolean | 
final Boolean minExtInfo = new Boolean(); // Boolean | 

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | GUID for the entity
        Boolean ignoreRelationships = true; // Boolean | 
        Boolean minExtInfo = true; // Boolean | 

        try {
            AtlasEntityWithExtInfo result = apiInstance.getById(guid, ignoreRelationships, minExtInfo);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#getById");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
String *guid = guid_example; // GUID for the entity (default to null)
Boolean *ignoreRelationships = true; //  (optional) (default to false)
Boolean *minExtInfo = true; //  (optional) (default to false)

[apiInstance getByIdWith:guid
    ignoreRelationships:ignoreRelationships
    minExtInfo:minExtInfo
              completionHandler: ^(AtlasEntityWithExtInfo output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var guid = guid_example; // {String} GUID for the entity
var opts = {
  'ignoreRelationships': true, // {Boolean} 
  'minExtInfo': true // {Boolean} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var guid = guid_example;  // String | GUID for the entity (default to null)
            var ignoreRelationships = true;  // Boolean |  (optional)  (default to false)
            var minExtInfo = true;  // Boolean |  (optional)  (default to false)

            try {
                AtlasEntityWithExtInfo result = apiInstance.getById(guid, ignoreRelationships, minExtInfo);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.getById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$guid = guid_example; // String | GUID for the entity
$ignoreRelationships = true; // Boolean | 
$minExtInfo = true; // Boolean | 

try {
    $result = $api_instance->getById($guid, $ignoreRelationships, $minExtInfo);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling EntityRESTApi->getById: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $guid = guid_example; # String | GUID for the entity
my $ignoreRelationships = true; # Boolean | 
my $minExtInfo = true; # Boolean | 

eval {
    my $result = $api_instance->getById(guid => $guid, ignoreRelationships => $ignoreRelationships, minExtInfo => $minExtInfo);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->getById: $@\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.EntityRESTApi()
guid = guid_example # String | GUID for the entity (default to null)
ignoreRelationships = true # Boolean |  (optional) (default to false)
minExtInfo = true # Boolean |  (optional) (default to false)

try:
    api_response = api_instance.get_by_id(guid, ignoreRelationships=ignoreRelationships, minExtInfo=minExtInfo)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EntityRESTApi->getById: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let guid = guid_example; // String
    let ignoreRelationships = true; // Boolean
    let minExtInfo = true; // Boolean

    let mut context = EntityRESTApi::Context::default();
    let result = client.getById(guid, ignoreRelationships, minExtInfo, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | 
        Boolean ignoreRelationships = true; // Boolean | 
        Boolean minExtInfo = true; // Boolean | 

        try {
            AtlasEntityWithExtInfo result = apiInstance.getByUniqueAttributes(typeName, ignoreRelationships, minExtInfo);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#getByUniqueAttributes");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String typeName = new String(); // String | 
final Boolean ignoreRelationships = new Boolean(); // Boolean | 
final Boolean minExtInfo = new Boolean(); // Boolean | 

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | 
        Boolean ignoreRelationships = true; // Boolean | 
        Boolean minExtInfo = true; // Boolean | 

        try {
            AtlasEntityWithExtInfo result = apiInstance.getByUniqueAttributes(typeName, ignoreRelationships, minExtInfo);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#getByUniqueAttributes");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
String *typeName = typeName_example; //  (default to null)
Boolean *ignoreRelationships = true; //  (optional) (default to false)
Boolean *minExtInfo = true; //  (optional) (default to false)

[apiInstance getByUniqueAttributesWith:typeName
    ignoreRelationships:ignoreRelationships
    minExtInfo:minExtInfo
              completionHandler: ^(AtlasEntityWithExtInfo output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var typeName = typeName_example; // {String} 
var opts = {
  'ignoreRelationships': true, // {Boolean} 
  'minExtInfo': true // {Boolean} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var typeName = typeName_example;  // String |  (default to null)
            var ignoreRelationships = true;  // Boolean |  (optional)  (default to false)
            var minExtInfo = true;  // Boolean |  (optional)  (default to false)

            try {
                AtlasEntityWithExtInfo result = apiInstance.getByUniqueAttributes(typeName, ignoreRelationships, minExtInfo);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.getByUniqueAttributes: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$typeName = typeName_example; // String | 
$ignoreRelationships = true; // Boolean | 
$minExtInfo = true; // Boolean | 

try {
    $result = $api_instance->getByUniqueAttributes($typeName, $ignoreRelationships, $minExtInfo);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling EntityRESTApi->getByUniqueAttributes: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $typeName = typeName_example; # String | 
my $ignoreRelationships = true; # Boolean | 
my $minExtInfo = true; # Boolean | 

eval {
    my $result = $api_instance->getByUniqueAttributes(typeName => $typeName, ignoreRelationships => $ignoreRelationships, minExtInfo => $minExtInfo);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->getByUniqueAttributes: $@\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.EntityRESTApi()
typeName = typeName_example # String |  (default to null)
ignoreRelationships = true # Boolean |  (optional) (default to false)
minExtInfo = true # Boolean |  (optional) (default to false)

try:
    api_response = api_instance.get_by_unique_attributes(typeName, ignoreRelationships=ignoreRelationships, minExtInfo=minExtInfo)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EntityRESTApi->getByUniqueAttributes: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let typeName = typeName_example; // String
    let ignoreRelationships = true; // Boolean
    let minExtInfo = true; // Boolean

    let mut context = EntityRESTApi::Context::default();
    let result = client.getByUniqueAttributes(typeName, ignoreRelationships, minExtInfo, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        String classificationName = classificationName_example; // String | 
        String guid = guid_example; // String | globally unique identifier for the entity

        try {
            AtlasClassification result = apiInstance.getClassification(classificationName, guid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#getClassification");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String classificationName = new String(); // String | 
final String guid = new String(); // String | globally unique identifier for the entity

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String classificationName = classificationName_example; // String | 
        String guid = guid_example; // String | globally unique identifier for the entity

        try {
            AtlasClassification result = apiInstance.getClassification(classificationName, guid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#getClassification");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
String *classificationName = classificationName_example; //  (default to null)
String *guid = guid_example; // globally unique identifier for the entity (default to null)

[apiInstance getClassificationWith:classificationName
    guid:guid
              completionHandler: ^(AtlasClassification output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var classificationName = classificationName_example; // {String} 
var guid = guid_example; // {String} globally unique identifier for the entity

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var classificationName = classificationName_example;  // String |  (default to null)
            var guid = guid_example;  // String | globally unique identifier for the entity (default to null)

            try {
                AtlasClassification result = apiInstance.getClassification(classificationName, guid);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.getClassification: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$classificationName = classificationName_example; // String | 
$guid = guid_example; // String | globally unique identifier for the entity

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $classificationName = classificationName_example; # String | 
my $guid = guid_example; # String | globally unique identifier for the entity

eval {
    my $result = $api_instance->getClassification(classificationName => $classificationName, guid => $guid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->getClassification: $@\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.EntityRESTApi()
classificationName = classificationName_example # String |  (default to null)
guid = guid_example # String | globally unique identifier for the entity (default to null)

try:
    api_response = api_instance.get_classification(classificationName, guid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EntityRESTApi->getClassification: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let classificationName = classificationName_example; // String
    let guid = guid_example; // String

    let mut context = EntityRESTApi::Context::default();
    let result = client.getClassification(classificationName, guid, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | globally unique identifier for the entity

        try {
            AtlasClassifications result = apiInstance.getClassifications(guid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#getClassifications");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String guid = new String(); // String | globally unique identifier for the entity

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | globally unique identifier for the entity

        try {
            AtlasClassifications result = apiInstance.getClassifications(guid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#getClassifications");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
String *guid = guid_example; // globally unique identifier for the entity (default to null)

[apiInstance getClassificationsWith:guid
              completionHandler: ^(AtlasClassifications output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var guid = guid_example; // {String} globally unique identifier for the entity

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var guid = guid_example;  // String | globally unique identifier for the entity (default to null)

            try {
                AtlasClassifications result = apiInstance.getClassifications(guid);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.getClassifications: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$guid = guid_example; // String | globally unique identifier for the entity

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $guid = guid_example; # String | globally unique identifier for the entity

eval {
    my $result = $api_instance->getClassifications(guid => $guid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->getClassifications: $@\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.EntityRESTApi()
guid = guid_example # String | globally unique identifier for the entity (default to null)

try:
    api_response = api_instance.get_classifications(guid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EntityRESTApi->getClassifications: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let guid = guid_example; // String

    let mut context = EntityRESTApi::Context::default();
    let result = client.getClassifications(guid, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | 
        Boolean ignoreRelationships = true; // Boolean | 
        Boolean minExtInfo = true; // Boolean | 

        try {
            AtlasEntitiesWithExtInfo result = apiInstance.getEntitiesByUniqueAttributes(typeName, ignoreRelationships, minExtInfo);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#getEntitiesByUniqueAttributes");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String typeName = new String(); // String | 
final Boolean ignoreRelationships = new Boolean(); // Boolean | 
final Boolean minExtInfo = new Boolean(); // Boolean | 

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | 
        Boolean ignoreRelationships = true; // Boolean | 
        Boolean minExtInfo = true; // Boolean | 

        try {
            AtlasEntitiesWithExtInfo result = apiInstance.getEntitiesByUniqueAttributes(typeName, ignoreRelationships, minExtInfo);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#getEntitiesByUniqueAttributes");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
String *typeName = typeName_example; //  (default to null)
Boolean *ignoreRelationships = true; //  (optional) (default to false)
Boolean *minExtInfo = true; //  (optional) (default to false)

[apiInstance getEntitiesByUniqueAttributesWith:typeName
    ignoreRelationships:ignoreRelationships
    minExtInfo:minExtInfo
              completionHandler: ^(AtlasEntitiesWithExtInfo output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var typeName = typeName_example; // {String} 
var opts = {
  'ignoreRelationships': true, // {Boolean} 
  'minExtInfo': true // {Boolean} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var typeName = typeName_example;  // String |  (default to null)
            var ignoreRelationships = true;  // Boolean |  (optional)  (default to false)
            var minExtInfo = true;  // Boolean |  (optional)  (default to false)

            try {
                AtlasEntitiesWithExtInfo result = apiInstance.getEntitiesByUniqueAttributes(typeName, ignoreRelationships, minExtInfo);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.getEntitiesByUniqueAttributes: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$typeName = typeName_example; // String | 
$ignoreRelationships = true; // Boolean | 
$minExtInfo = true; // Boolean | 

try {
    $result = $api_instance->getEntitiesByUniqueAttributes($typeName, $ignoreRelationships, $minExtInfo);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling EntityRESTApi->getEntitiesByUniqueAttributes: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $typeName = typeName_example; # String | 
my $ignoreRelationships = true; # Boolean | 
my $minExtInfo = true; # Boolean | 

eval {
    my $result = $api_instance->getEntitiesByUniqueAttributes(typeName => $typeName, ignoreRelationships => $ignoreRelationships, minExtInfo => $minExtInfo);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->getEntitiesByUniqueAttributes: $@\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.EntityRESTApi()
typeName = typeName_example # String |  (default to null)
ignoreRelationships = true # Boolean |  (optional) (default to false)
minExtInfo = true # Boolean |  (optional) (default to false)

try:
    api_response = api_instance.get_entities_by_unique_attributes(typeName, ignoreRelationships=ignoreRelationships, minExtInfo=minExtInfo)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EntityRESTApi->getEntitiesByUniqueAttributes: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let typeName = typeName_example; // String
    let ignoreRelationships = true; // Boolean
    let minExtInfo = true; // Boolean

    let mut context = EntityRESTApi::Context::default();
    let result = client.getEntitiesByUniqueAttributes(typeName, ignoreRelationships, minExtInfo, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | 

        try {
            AtlasEntityHeader result = apiInstance.getEntityHeaderByUniqueAttributes(typeName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#getEntityHeaderByUniqueAttributes");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | 

        try {
            AtlasEntityHeader result = apiInstance.getEntityHeaderByUniqueAttributes(typeName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#getEntityHeaderByUniqueAttributes");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
String *typeName = typeName_example; //  (default to null)

[apiInstance getEntityHeaderByUniqueAttributesWith:typeName
              completionHandler: ^(AtlasEntityHeader output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var typeName = typeName_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var typeName = typeName_example;  // String |  (default to null)

            try {
                AtlasEntityHeader result = apiInstance.getEntityHeaderByUniqueAttributes(typeName);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.getEntityHeaderByUniqueAttributes: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$typeName = typeName_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $typeName = typeName_example; # String | 

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

try:
    api_response = api_instance.get_entity_header_by_unique_attributes(typeName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EntityRESTApi->getEntityHeaderByUniqueAttributes: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let typeName = typeName_example; // String

    let mut context = EntityRESTApi::Context::default();
    let result = client.getEntityHeaderByUniqueAttributes(typeName, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        Long tagUpdateStartTime = 789; // Long | 

        try {
            AtlasEntityHeaders result = apiInstance.getEntityHeaders(tagUpdateStartTime);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#getEntityHeaders");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long tagUpdateStartTime = new Long(); // Long | 

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        Long tagUpdateStartTime = 789; // Long | 

        try {
            AtlasEntityHeaders result = apiInstance.getEntityHeaders(tagUpdateStartTime);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#getEntityHeaders");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
Long *tagUpdateStartTime = 789; //  (default to null)

[apiInstance getEntityHeadersWith:tagUpdateStartTime
              completionHandler: ^(AtlasEntityHeaders output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var tagUpdateStartTime = 789; // {Long} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var tagUpdateStartTime = 789;  // Long |  (default to null)

            try {
                AtlasEntityHeaders result = apiInstance.getEntityHeaders(tagUpdateStartTime);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.getEntityHeaders: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$tagUpdateStartTime = 789; // Long | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $tagUpdateStartTime = 789; # Long | 

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

try:
    api_response = api_instance.get_entity_headers(tagUpdateStartTime)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EntityRESTApi->getEntityHeaders: %s\n" % e)

extern crate EntityRESTApi;

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

    let mut context = EntityRESTApi::Context::default();
    let result = client.getEntityHeaders(tagUpdateStartTime, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | GUID for the entity

        try {
            AtlasEntityHeader result = apiInstance.getHeaderById(guid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#getHeaderById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String guid = new String(); // String | GUID for the entity

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | GUID for the entity

        try {
            AtlasEntityHeader result = apiInstance.getHeaderById(guid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#getHeaderById");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
String *guid = guid_example; // GUID for the entity (default to null)

[apiInstance getHeaderByIdWith:guid
              completionHandler: ^(AtlasEntityHeader output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var guid = guid_example; // {String} GUID for the entity

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var guid = guid_example;  // String | GUID for the entity (default to null)

            try {
                AtlasEntityHeader result = apiInstance.getHeaderById(guid);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.getHeaderById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$guid = guid_example; // String | GUID for the entity

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $guid = guid_example; # String | GUID for the entity

eval {
    my $result = $api_instance->getHeaderById(guid => $guid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->getHeaderById: $@\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.EntityRESTApi()
guid = guid_example # String | GUID for the entity (default to null)

try:
    api_response = api_instance.get_header_by_id(guid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EntityRESTApi->getHeaderById: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let guid = guid_example; // String

    let mut context = EntityRESTApi::Context::default();
    let result = client.getHeaderById(guid, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        String fileDetail = fileDetail_example; // String | FormDataContentDisposition metadata of file
        String uploadedInputStream = uploadedInputStream_example; // String | InputStream of file

        try {
            apiInstance.importBMAttributes(fileDetail, uploadedInputStream);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#importBMAttributes");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String fileDetail = new String(); // String | FormDataContentDisposition metadata of file
final String uploadedInputStream = new String(); // String | InputStream of file

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String fileDetail = fileDetail_example; // String | FormDataContentDisposition metadata of file
        String uploadedInputStream = uploadedInputStream_example; // String | InputStream of file

        try {
            apiInstance.importBMAttributes(fileDetail, uploadedInputStream);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#importBMAttributes");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
String *fileDetail = fileDetail_example; // FormDataContentDisposition metadata of file (optional) (default to null)
String *uploadedInputStream = uploadedInputStream_example; // InputStream of file (optional) (default to null)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var opts = {
  'fileDetail': fileDetail_example, // {String} FormDataContentDisposition metadata of file
  'uploadedInputStream': uploadedInputStream_example // {String} InputStream of file
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var fileDetail = fileDetail_example;  // String | FormDataContentDisposition metadata of file (optional)  (default to null)
            var uploadedInputStream = uploadedInputStream_example;  // String | InputStream of file (optional)  (default to null)

            try {
                apiInstance.importBMAttributes(fileDetail, uploadedInputStream);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.importBMAttributes: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$fileDetail = fileDetail_example; // String | FormDataContentDisposition metadata of file
$uploadedInputStream = uploadedInputStream_example; // String | InputStream of file

try {
    $api_instance->importBMAttributes($fileDetail, $uploadedInputStream);
} catch (Exception $e) {
    echo 'Exception when calling EntityRESTApi->importBMAttributes: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $fileDetail = fileDetail_example; # String | FormDataContentDisposition metadata of file
my $uploadedInputStream = uploadedInputStream_example; # String | InputStream of file

eval {
    $api_instance->importBMAttributes(fileDetail => $fileDetail, uploadedInputStream => $uploadedInputStream);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->importBMAttributes: $@\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.EntityRESTApi()
fileDetail = fileDetail_example # String | FormDataContentDisposition metadata of file (optional) (default to null)
uploadedInputStream = uploadedInputStream_example # String | InputStream of file (optional) (default to null)

try:
    api_instance.import_bm_attributes(fileDetail=fileDetail, uploadedInputStream=uploadedInputStream)
except ApiException as e:
    print("Exception when calling EntityRESTApi->importBMAttributes: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let fileDetail = fileDetail_example; // String
    let uploadedInputStream = uploadedInputStream_example; // String

    let mut context = EntityRESTApi::Context::default();
    let result = client.importBMAttributes(fileDetail, uploadedInputStream, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | 
        String name = name_example; // String | 
        String body = body_example; // String | 

        try {
            EntityMutationResponse result = apiInstance.partialUpdateEntityAttrByGuid(guid, name, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#partialUpdateEntityAttrByGuid");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | 
        String name = name_example; // String | 
        String body = body_example; // String | 

        try {
            EntityMutationResponse result = apiInstance.partialUpdateEntityAttrByGuid(guid, name, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#partialUpdateEntityAttrByGuid");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
String *guid = guid_example; //  (default to null)
String *name = name_example; //  (optional) (default to null)
String *body = body_example; //  (optional)

[apiInstance partialUpdateEntityAttrByGuidWith:guid
    name:name
    body:body
              completionHandler: ^(EntityMutationResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var guid = guid_example; // {String} 
var opts = {
  'name': name_example, // {String} 
  'body': body_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var guid = guid_example;  // String |  (default to null)
            var name = name_example;  // String |  (optional)  (default to null)
            var body = body_example;  // String |  (optional) 

            try {
                EntityMutationResponse result = apiInstance.partialUpdateEntityAttrByGuid(guid, name, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.partialUpdateEntityAttrByGuid: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$guid = guid_example; // String | 
$name = name_example; // String | 
$body = body_example; // String | 

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

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

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

eval {
    my $result = $api_instance->partialUpdateEntityAttrByGuid(guid => $guid, name => $name, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->partialUpdateEntityAttrByGuid: $@\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.EntityRESTApi()
guid = guid_example # String |  (default to null)
name = name_example # String |  (optional) (default to null)
body = body_example # String |  (optional)

try:
    api_response = api_instance.partial_update_entity_attr_by_guid(guid, name=name, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EntityRESTApi->partialUpdateEntityAttrByGuid: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let guid = guid_example; // String
    let name = name_example; // String
    let body = body_example; // String

    let mut context = EntityRESTApi::Context::default();
    let result = client.partialUpdateEntityAttrByGuid(guid, name, body, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | 
        AtlasEntityWithExtInfo atlasEntityWithExtInfo = {"entity":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"PROPOSED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"DELETED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"referredEntities":{"property1":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"PROPOSED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"property2":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"VALIDATED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."}}}; // AtlasEntityWithExtInfo | 

        try {
            EntityMutationResponse result = apiInstance.partialUpdateEntityByUniqueAttrs(typeName, atlasEntityWithExtInfo);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#partialUpdateEntityByUniqueAttrs");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String typeName = new String(); // String | 
final AtlasEntityWithExtInfo atlasEntityWithExtInfo = new AtlasEntityWithExtInfo(); // AtlasEntityWithExtInfo | 

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | 
        AtlasEntityWithExtInfo atlasEntityWithExtInfo = {"entity":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"PROPOSED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"DELETED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"referredEntities":{"property1":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"PROPOSED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"property2":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"VALIDATED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."}}}; // AtlasEntityWithExtInfo | 

        try {
            EntityMutationResponse result = apiInstance.partialUpdateEntityByUniqueAttrs(typeName, atlasEntityWithExtInfo);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#partialUpdateEntityByUniqueAttrs");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
String *typeName = typeName_example; //  (default to null)
AtlasEntityWithExtInfo *atlasEntityWithExtInfo = {"entity":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"PROPOSED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"DELETED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"referredEntities":{"property1":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"PROPOSED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"property2":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"VALIDATED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."}}}; //  (optional)

[apiInstance partialUpdateEntityByUniqueAttrsWith:typeName
    atlasEntityWithExtInfo:atlasEntityWithExtInfo
              completionHandler: ^(EntityMutationResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var typeName = typeName_example; // {String} 
var opts = {
  'atlasEntityWithExtInfo': {"entity":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"PROPOSED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"DELETED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"referredEntities":{"property1":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"PROPOSED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"property2":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"VALIDATED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."}}} // {AtlasEntityWithExtInfo} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var typeName = typeName_example;  // String |  (default to null)
            var atlasEntityWithExtInfo = new AtlasEntityWithExtInfo(); // AtlasEntityWithExtInfo |  (optional) 

            try {
                EntityMutationResponse result = apiInstance.partialUpdateEntityByUniqueAttrs(typeName, atlasEntityWithExtInfo);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.partialUpdateEntityByUniqueAttrs: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$typeName = typeName_example; // String | 
$atlasEntityWithExtInfo = {"entity":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"PROPOSED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"DELETED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"referredEntities":{"property1":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"PROPOSED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"property2":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"VALIDATED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."}}}; // AtlasEntityWithExtInfo | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $typeName = typeName_example; # String | 
my $atlasEntityWithExtInfo = WWW::OPenAPIClient::Object::AtlasEntityWithExtInfo->new(); # AtlasEntityWithExtInfo | 

eval {
    my $result = $api_instance->partialUpdateEntityByUniqueAttrs(typeName => $typeName, atlasEntityWithExtInfo => $atlasEntityWithExtInfo);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->partialUpdateEntityByUniqueAttrs: $@\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.EntityRESTApi()
typeName = typeName_example # String |  (default to null)
atlasEntityWithExtInfo = {"entity":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"PROPOSED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"DELETED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"referredEntities":{"property1":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"PROPOSED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"property2":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"VALIDATED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."}}} # AtlasEntityWithExtInfo |  (optional)

try:
    api_response = api_instance.partial_update_entity_by_unique_attrs(typeName, atlasEntityWithExtInfo=atlasEntityWithExtInfo)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EntityRESTApi->partialUpdateEntityByUniqueAttrs: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let typeName = typeName_example; // String
    let atlasEntityWithExtInfo = {"entity":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"PROPOSED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"DELETED","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"referredEntities":{"property1":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"PROPOSED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."},"property2":{"businessAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"createTime":12345,"createdBy":"...","customAttributes":{"property1":"...","property2":"..."},"guid":"...","homeId":"...","isIncomplete":true,"labels":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"VALIDATED","steward":"...","termGuid":"..."}],"pendingTasks":["...","..."],"provenanceType":12345,"proxy":true,"relationshipAttributes":{"property1":{},"property2":{}},"status":"ACTIVE","updateTime":12345,"updatedBy":"...","version":12345,"attributes":{"property1":{},"property2":{}},"typeName":"..."}}}; // AtlasEntityWithExtInfo

    let mut context = EntityRESTApi::Context::default();
    let result = client.partialUpdateEntityByUniqueAttrs(typeName, atlasEntityWithExtInfo, &context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.EntityRESTApi;

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

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

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

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

var AtlasRestApi = require('atlas_rest_api');

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

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

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

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

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

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

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

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

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

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

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

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

extern crate EntityRESTApi;

pub fn main() {

    let mut context = EntityRESTApi::Context::default();
    let result = client.produceTemplate(&context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | 
        map[String, Object] requestBody = Object; // map[String, Object] | 

        try {
            apiInstance.removeBusinessAttributes(guid, requestBody);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#removeBusinessAttributes");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String guid = new String(); // String | 
final map[String, Object] requestBody = new map[String, Object](); // map[String, Object] | 

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | 
        map[String, Object] requestBody = Object; // map[String, Object] | 

        try {
            apiInstance.removeBusinessAttributes(guid, requestBody);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#removeBusinessAttributes");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
String *guid = guid_example; //  (default to null)
map[String, Object] *requestBody = Object; //  (optional)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var guid = guid_example; // {String} 
var opts = {
  'requestBody': Object // {map[String, Object]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var guid = guid_example;  // String |  (default to null)
            var requestBody = new map[String, Object](); // map[String, Object] |  (optional) 

            try {
                apiInstance.removeBusinessAttributes(guid, requestBody);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.removeBusinessAttributes: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$guid = guid_example; // String | 
$requestBody = Object; // map[String, Object] | 

try {
    $api_instance->removeBusinessAttributes($guid, $requestBody);
} catch (Exception $e) {
    echo 'Exception when calling EntityRESTApi->removeBusinessAttributes: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $guid = guid_example; # String | 
my $requestBody = WWW::OPenAPIClient::Object::map[String, Object]->new(); # map[String, Object] | 

eval {
    $api_instance->removeBusinessAttributes(guid => $guid, requestBody => $requestBody);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->removeBusinessAttributes: $@\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.EntityRESTApi()
guid = guid_example # String |  (default to null)
requestBody = Object # map[String, Object] |  (optional)

try:
    api_instance.remove_business_attributes(guid, requestBody=requestBody)
except ApiException as e:
    print("Exception when calling EntityRESTApi->removeBusinessAttributes: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let guid = guid_example; // String
    let requestBody = Object; // map[String, Object]

    let mut context = EntityRESTApi::Context::default();
    let result = client.removeBusinessAttributes(guid, requestBody, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        String bmName = bmName_example; // String | 
        String guid = guid_example; // String | 
        map[String, Object] requestBody = Object; // map[String, Object] | 

        try {
            apiInstance.removeBusinessAttributes2(bmName, guid, requestBody);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#removeBusinessAttributes2");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String bmName = new String(); // String | 
final String guid = new String(); // String | 
final map[String, Object] requestBody = new map[String, Object](); // map[String, Object] | 

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String bmName = bmName_example; // String | 
        String guid = guid_example; // String | 
        map[String, Object] requestBody = Object; // map[String, Object] | 

        try {
            apiInstance.removeBusinessAttributes2(bmName, guid, requestBody);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#removeBusinessAttributes2");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
String *bmName = bmName_example; //  (default to null)
String *guid = guid_example; //  (default to null)
map[String, Object] *requestBody = Object; //  (optional)

[apiInstance removeBusinessAttributes2With:bmName
    guid:guid
    requestBody:requestBody
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var bmName = bmName_example; // {String} 
var guid = guid_example; // {String} 
var opts = {
  'requestBody': Object // {map[String, Object]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var bmName = bmName_example;  // String |  (default to null)
            var guid = guid_example;  // String |  (default to null)
            var requestBody = new map[String, Object](); // map[String, Object] |  (optional) 

            try {
                apiInstance.removeBusinessAttributes2(bmName, guid, requestBody);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.removeBusinessAttributes2: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$bmName = bmName_example; // String | 
$guid = guid_example; // String | 
$requestBody = Object; // map[String, Object] | 

try {
    $api_instance->removeBusinessAttributes2($bmName, $guid, $requestBody);
} catch (Exception $e) {
    echo 'Exception when calling EntityRESTApi->removeBusinessAttributes2: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $bmName = bmName_example; # String | 
my $guid = guid_example; # String | 
my $requestBody = WWW::OPenAPIClient::Object::map[String, Object]->new(); # map[String, Object] | 

eval {
    $api_instance->removeBusinessAttributes2(bmName => $bmName, guid => $guid, requestBody => $requestBody);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->removeBusinessAttributes2: $@\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.EntityRESTApi()
bmName = bmName_example # String |  (default to null)
guid = guid_example # String |  (default to null)
requestBody = Object # map[String, Object] |  (optional)

try:
    api_instance.remove_business_attributes2(bmName, guid, requestBody=requestBody)
except ApiException as e:
    print("Exception when calling EntityRESTApi->removeBusinessAttributes2: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let bmName = bmName_example; // String
    let guid = guid_example; // String
    let requestBody = Object; // map[String, Object]

    let mut context = EntityRESTApi::Context::default();
    let result = client.removeBusinessAttributes2(bmName, guid, requestBody, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | - Unique entity identifier
        array[String] string = ; // array[String] | 

        try {
            apiInstance.removeLabels(guid, string);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#removeLabels");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String guid = new String(); // String | - Unique entity identifier
final array[String] string = new array[String](); // array[String] | 

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | - Unique entity identifier
        array[String] string = ; // array[String] | 

        try {
            apiInstance.removeLabels(guid, string);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#removeLabels");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
String *guid = guid_example; // - Unique entity identifier (default to null)
array[String] *string = ; //  (optional)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var guid = guid_example; // {String} - Unique entity identifier
var opts = {
  'string':  // {array[String]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var guid = guid_example;  // String | - Unique entity identifier (default to null)
            var string = new array[String](); // array[String] |  (optional) 

            try {
                apiInstance.removeLabels(guid, string);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.removeLabels: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$guid = guid_example; // String | - Unique entity identifier
$string = ; // array[String] | 

try {
    $api_instance->removeLabels($guid, $string);
} catch (Exception $e) {
    echo 'Exception when calling EntityRESTApi->removeLabels: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $guid = guid_example; # String | - Unique entity identifier
my $string = [WWW::OPenAPIClient::Object::array[String]->new()]; # array[String] | 

eval {
    $api_instance->removeLabels(guid => $guid, string => $string);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->removeLabels: $@\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.EntityRESTApi()
guid = guid_example # String | - Unique entity identifier (default to null)
string =  # array[String] |  (optional)

try:
    api_instance.remove_labels(guid, string=string)
except ApiException as e:
    print("Exception when calling EntityRESTApi->removeLabels: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let guid = guid_example; // String
    let string = ; // array[String]

    let mut context = EntityRESTApi::Context::default();
    let result = client.removeLabels(guid, string, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | 
        array[String] string = ; // array[String] | 

        try {
            apiInstance.removeLabels2(typeName, string);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#removeLabels2");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String typeName = new String(); // String | 
final array[String] string = new array[String](); // array[String] | 

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | 
        array[String] string = ; // array[String] | 

        try {
            apiInstance.removeLabels2(typeName, string);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#removeLabels2");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
String *typeName = typeName_example; //  (default to null)
array[String] *string = ; //  (optional)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var typeName = typeName_example; // {String} 
var opts = {
  'string':  // {array[String]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var typeName = typeName_example;  // String |  (default to null)
            var string = new array[String](); // array[String] |  (optional) 

            try {
                apiInstance.removeLabels2(typeName, string);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.removeLabels2: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$typeName = typeName_example; // String | 
$string = ; // array[String] | 

try {
    $api_instance->removeLabels2($typeName, $string);
} catch (Exception $e) {
    echo 'Exception when calling EntityRESTApi->removeLabels2: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $typeName = typeName_example; # String | 
my $string = [WWW::OPenAPIClient::Object::array[String]->new()]; # array[String] | 

eval {
    $api_instance->removeLabels2(typeName => $typeName, string => $string);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->removeLabels2: $@\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.EntityRESTApi()
typeName = typeName_example # String |  (default to null)
string =  # array[String] |  (optional)

try:
    api_instance.remove_labels2(typeName, string=string)
except ApiException as e:
    print("Exception when calling EntityRESTApi->removeLabels2: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let typeName = typeName_example; // String
    let string = ; // array[String]

    let mut context = EntityRESTApi::Context::default();
    let result = client.removeLabels2(typeName, string, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        AtlasEntityHeaders atlasEntityHeaders = {"guidHeaderMap":{"property1":{"classificationNames":["...","..."],"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"displayText":"...","guid":"...","isIncomplete":true,"labels":["...","..."],"meaningNames":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"VALIDATED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"status":"PURGED","attributes":{"property1":{},"property2":{}},"typeName":"..."},"property2":{"classificationNames":["...","..."],"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"displayText":"...","guid":"...","isIncomplete":true,"labels":["...","..."],"meaningNames":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"VALIDATED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"PROPOSED","steward":"...","termGuid":"..."}],"status":"PURGED","attributes":{"property1":{},"property2":{}},"typeName":"..."}}}; // AtlasEntityHeaders | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final AtlasEntityHeaders atlasEntityHeaders = new AtlasEntityHeaders(); // AtlasEntityHeaders | 

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        AtlasEntityHeaders atlasEntityHeaders = {"guidHeaderMap":{"property1":{"classificationNames":["...","..."],"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"displayText":"...","guid":"...","isIncomplete":true,"labels":["...","..."],"meaningNames":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"VALIDATED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"status":"PURGED","attributes":{"property1":{},"property2":{}},"typeName":"..."},"property2":{"classificationNames":["...","..."],"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"displayText":"...","guid":"...","isIncomplete":true,"labels":["...","..."],"meaningNames":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"VALIDATED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"PROPOSED","steward":"...","termGuid":"..."}],"status":"PURGED","attributes":{"property1":{},"property2":{}},"typeName":"..."}}}; // AtlasEntityHeaders | 

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

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
AtlasEntityHeaders *atlasEntityHeaders = {"guidHeaderMap":{"property1":{"classificationNames":["...","..."],"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"displayText":"...","guid":"...","isIncomplete":true,"labels":["...","..."],"meaningNames":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"VALIDATED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"status":"PURGED","attributes":{"property1":{},"property2":{}},"typeName":"..."},"property2":{"classificationNames":["...","..."],"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"displayText":"...","guid":"...","isIncomplete":true,"labels":["...","..."],"meaningNames":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"VALIDATED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"PROPOSED","steward":"...","termGuid":"..."}],"status":"PURGED","attributes":{"property1":{},"property2":{}},"typeName":"..."}}}; //  (optional)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var opts = {
  'atlasEntityHeaders': {"guidHeaderMap":{"property1":{"classificationNames":["...","..."],"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"displayText":"...","guid":"...","isIncomplete":true,"labels":["...","..."],"meaningNames":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"VALIDATED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"status":"PURGED","attributes":{"property1":{},"property2":{}},"typeName":"..."},"property2":{"classificationNames":["...","..."],"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"displayText":"...","guid":"...","isIncomplete":true,"labels":["...","..."],"meaningNames":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"VALIDATED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"PROPOSED","steward":"...","termGuid":"..."}],"status":"PURGED","attributes":{"property1":{},"property2":{}},"typeName":"..."}}} // {AtlasEntityHeaders} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var atlasEntityHeaders = new AtlasEntityHeaders(); // AtlasEntityHeaders |  (optional) 

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$atlasEntityHeaders = {"guidHeaderMap":{"property1":{"classificationNames":["...","..."],"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"displayText":"...","guid":"...","isIncomplete":true,"labels":["...","..."],"meaningNames":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"VALIDATED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"status":"PURGED","attributes":{"property1":{},"property2":{}},"typeName":"..."},"property2":{"classificationNames":["...","..."],"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"displayText":"...","guid":"...","isIncomplete":true,"labels":["...","..."],"meaningNames":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"VALIDATED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"PROPOSED","steward":"...","termGuid":"..."}],"status":"PURGED","attributes":{"property1":{},"property2":{}},"typeName":"..."}}}; // AtlasEntityHeaders | 

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

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

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

eval {
    my $result = $api_instance->setClassifications(atlasEntityHeaders => $atlasEntityHeaders);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->setClassifications: $@\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.EntityRESTApi()
atlasEntityHeaders = {"guidHeaderMap":{"property1":{"classificationNames":["...","..."],"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"displayText":"...","guid":"...","isIncomplete":true,"labels":["...","..."],"meaningNames":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"VALIDATED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"status":"PURGED","attributes":{"property1":{},"property2":{}},"typeName":"..."},"property2":{"classificationNames":["...","..."],"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"displayText":"...","guid":"...","isIncomplete":true,"labels":["...","..."],"meaningNames":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"VALIDATED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"PROPOSED","steward":"...","termGuid":"..."}],"status":"PURGED","attributes":{"property1":{},"property2":{}},"typeName":"..."}}} # AtlasEntityHeaders |  (optional)

try:
    api_response = api_instance.set_classifications(atlasEntityHeaders=atlasEntityHeaders)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EntityRESTApi->setClassifications: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let atlasEntityHeaders = {"guidHeaderMap":{"property1":{"classificationNames":["...","..."],"classifications":[{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"displayText":"...","guid":"...","isIncomplete":true,"labels":["...","..."],"meaningNames":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"VALIDATED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"status":"PURGED","attributes":{"property1":{},"property2":{}},"typeName":"..."},"property2":{"classificationNames":["...","..."],"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{},{}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"displayText":"...","guid":"...","isIncomplete":true,"labels":["...","..."],"meaningNames":["...","..."],"meanings":[{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"VALIDATED","steward":"...","termGuid":"..."},{"confidence":12345,"createdBy":"...","description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"PROPOSED","steward":"...","termGuid":"..."}],"status":"PURGED","attributes":{"property1":{},"property2":{}},"typeName":"..."}}}; // AtlasEntityHeaders

    let mut context = EntityRESTApi::Context::default();
    let result = client.setClassifications(atlasEntityHeaders, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | - Unique entity identifier
        array[String] string = ; // array[String] | 

        try {
            apiInstance.setLabels(guid, string);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#setLabels");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String guid = new String(); // String | - Unique entity identifier
final array[String] string = new array[String](); // array[String] | 

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | - Unique entity identifier
        array[String] string = ; // array[String] | 

        try {
            apiInstance.setLabels(guid, string);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#setLabels");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
String *guid = guid_example; // - Unique entity identifier (default to null)
array[String] *string = ; //  (optional)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var guid = guid_example; // {String} - Unique entity identifier
var opts = {
  'string':  // {array[String]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var guid = guid_example;  // String | - Unique entity identifier (default to null)
            var string = new array[String](); // array[String] |  (optional) 

            try {
                apiInstance.setLabels(guid, string);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.setLabels: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$guid = guid_example; // String | - Unique entity identifier
$string = ; // array[String] | 

try {
    $api_instance->setLabels($guid, $string);
} catch (Exception $e) {
    echo 'Exception when calling EntityRESTApi->setLabels: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $guid = guid_example; # String | - Unique entity identifier
my $string = [WWW::OPenAPIClient::Object::array[String]->new()]; # array[String] | 

eval {
    $api_instance->setLabels(guid => $guid, string => $string);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->setLabels: $@\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.EntityRESTApi()
guid = guid_example # String | - Unique entity identifier (default to null)
string =  # array[String] |  (optional)

try:
    api_instance.set_labels(guid, string=string)
except ApiException as e:
    print("Exception when calling EntityRESTApi->setLabels: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let guid = guid_example; // String
    let string = ; // array[String]

    let mut context = EntityRESTApi::Context::default();
    let result = client.setLabels(guid, string, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | 
        array[String] string = ; // array[String] | 

        try {
            apiInstance.setLabels2(typeName, string);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#setLabels2");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String typeName = new String(); // String | 
final array[String] string = new array[String](); // array[String] | 

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | 
        array[String] string = ; // array[String] | 

        try {
            apiInstance.setLabels2(typeName, string);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#setLabels2");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
String *typeName = typeName_example; //  (default to null)
array[String] *string = ; //  (optional)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var typeName = typeName_example; // {String} 
var opts = {
  'string':  // {array[String]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var typeName = typeName_example;  // String |  (default to null)
            var string = new array[String](); // array[String] |  (optional) 

            try {
                apiInstance.setLabels2(typeName, string);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.setLabels2: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$typeName = typeName_example; // String | 
$string = ; // array[String] | 

try {
    $api_instance->setLabels2($typeName, $string);
} catch (Exception $e) {
    echo 'Exception when calling EntityRESTApi->setLabels2: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $typeName = typeName_example; # String | 
my $string = [WWW::OPenAPIClient::Object::array[String]->new()]; # array[String] | 

eval {
    $api_instance->setLabels2(typeName => $typeName, string => $string);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->setLabels2: $@\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.EntityRESTApi()
typeName = typeName_example # String |  (default to null)
string =  # array[String] |  (optional)

try:
    api_instance.set_labels2(typeName, string=string)
except ApiException as e:
    print("Exception when calling EntityRESTApi->setLabels2: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let typeName = typeName_example; // String
    let string = ; // array[String]

    let mut context = EntityRESTApi::Context::default();
    let result = client.setLabels2(typeName, string, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | globally unique identifier for the entity
        array[AtlasClassification] atlasClassification = [{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}]; // array[AtlasClassification] | 

        try {
            apiInstance.updateClassifications(guid, atlasClassification);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#updateClassifications");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String guid = new String(); // String | globally unique identifier for the entity
final array[AtlasClassification] atlasClassification = new array[AtlasClassification](); // array[AtlasClassification] | 

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | globally unique identifier for the entity
        array[AtlasClassification] atlasClassification = [{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}]; // array[AtlasClassification] | 

        try {
            apiInstance.updateClassifications(guid, atlasClassification);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#updateClassifications");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
String *guid = guid_example; // globally unique identifier for the entity (default to null)
array[AtlasClassification] *atlasClassification = [{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}]; //  (optional)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var guid = guid_example; // {String} globally unique identifier for the entity
var opts = {
  'atlasClassification': [{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}] // {array[AtlasClassification]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var guid = guid_example;  // String | globally unique identifier for the entity (default to null)
            var atlasClassification = new array[AtlasClassification](); // array[AtlasClassification] |  (optional) 

            try {
                apiInstance.updateClassifications(guid, atlasClassification);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.updateClassifications: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$guid = guid_example; // String | globally unique identifier for the entity
$atlasClassification = [{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}]; // array[AtlasClassification] | 

try {
    $api_instance->updateClassifications($guid, $atlasClassification);
} catch (Exception $e) {
    echo 'Exception when calling EntityRESTApi->updateClassifications: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $guid = guid_example; # String | globally unique identifier for the entity
my $atlasClassification = [WWW::OPenAPIClient::Object::array[AtlasClassification]->new()]; # array[AtlasClassification] | 

eval {
    $api_instance->updateClassifications(guid => $guid, atlasClassification => $atlasClassification);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->updateClassifications: $@\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.EntityRESTApi()
guid = guid_example # String | globally unique identifier for the entity (default to null)
atlasClassification = [{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}] # array[AtlasClassification] |  (optional)

try:
    api_instance.update_classifications(guid, atlasClassification=atlasClassification)
except ApiException as e:
    print("Exception when calling EntityRESTApi->updateClassifications: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let guid = guid_example; // String
    let atlasClassification = [{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}]; // array[AtlasClassification]

    let mut context = EntityRESTApi::Context::default();
    let result = client.updateClassifications(guid, atlasClassification, &context).wait();

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

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

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

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

        // Create an instance of the API class
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | 
        array[AtlasClassification] atlasClassification = [{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}]; // array[AtlasClassification] | 

        try {
            apiInstance.updateClassificationsByUniqueAttribute(typeName, atlasClassification);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#updateClassificationsByUniqueAttribute");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String typeName = new String(); // String | 
final array[AtlasClassification] atlasClassification = new array[AtlasClassification](); // array[AtlasClassification] | 

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

import org.openapitools.client.api.EntityRESTApi;

public class EntityRESTApiExample {
    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | 
        array[AtlasClassification] atlasClassification = [{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}]; // array[AtlasClassification] | 

        try {
            apiInstance.updateClassificationsByUniqueAttribute(typeName, atlasClassification);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#updateClassificationsByUniqueAttribute");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];
String *typeName = typeName_example; //  (default to null)
array[AtlasClassification] *atlasClassification = [{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}]; //  (optional)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.EntityRESTApi()
var typeName = typeName_example; // {String} 
var opts = {
  'atlasClassification': [{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}] // {array[AtlasClassification]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new EntityRESTApi();
            var typeName = typeName_example;  // String |  (default to null)
            var atlasClassification = new array[AtlasClassification](); // array[AtlasClassification] |  (optional) 

            try {
                apiInstance.updateClassificationsByUniqueAttribute(typeName, atlasClassification);
            } catch (Exception e) {
                Debug.Print("Exception when calling EntityRESTApi.updateClassificationsByUniqueAttribute: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EntityRESTApi();
$typeName = typeName_example; // String | 
$atlasClassification = [{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}]; // array[AtlasClassification] | 

try {
    $api_instance->updateClassificationsByUniqueAttribute($typeName, $atlasClassification);
} catch (Exception $e) {
    echo 'Exception when calling EntityRESTApi->updateClassificationsByUniqueAttribute: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EntityRESTApi->new();
my $typeName = typeName_example; # String | 
my $atlasClassification = [WWW::OPenAPIClient::Object::array[AtlasClassification]->new()]; # array[AtlasClassification] | 

eval {
    $api_instance->updateClassificationsByUniqueAttribute(typeName => $typeName, atlasClassification => $atlasClassification);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->updateClassificationsByUniqueAttribute: $@\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.EntityRESTApi()
typeName = typeName_example # String |  (default to null)
atlasClassification = [{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}] # array[AtlasClassification] |  (optional)

try:
    api_instance.update_classifications_by_unique_attribute(typeName, atlasClassification=atlasClassification)
except ApiException as e:
    print("Exception when calling EntityRESTApi->updateClassificationsByUniqueAttribute: %s\n" % e)

extern crate EntityRESTApi;

pub fn main() {
    let typeName = typeName_example; // String
    let atlasClassification = [{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}]; // array[AtlasClassification]

    let mut context = EntityRESTApi::Context::default();
    let result = client.updateClassificationsByUniqueAttribute(typeName, atlasClassification, &context).wait();

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

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

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

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

        // Create an instance of the API class
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String termGuid = termGuid_example; // String | Glossary term GUID
        array[AtlasRelatedObjectId] atlasRelatedObjectId = [{"displayText":"...","entityStatus":"ACTIVE","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"ACTIVE","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}}]; // array[AtlasRelatedObjectId] | 

        try {
            apiInstance.assignTermToEntities(termGuid, atlasRelatedObjectId);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#assignTermToEntities");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String termGuid = new String(); // String | Glossary term GUID
final array[AtlasRelatedObjectId] atlasRelatedObjectId = new array[AtlasRelatedObjectId](); // array[AtlasRelatedObjectId] | 

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

import org.openapitools.client.api.GlossaryRESTApi;

public class GlossaryRESTApiExample {
    public static void main(String[] args) {
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String termGuid = termGuid_example; // String | Glossary term GUID
        array[AtlasRelatedObjectId] atlasRelatedObjectId = [{"displayText":"...","entityStatus":"ACTIVE","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"ACTIVE","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}}]; // array[AtlasRelatedObjectId] | 

        try {
            apiInstance.assignTermToEntities(termGuid, atlasRelatedObjectId);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#assignTermToEntities");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];
String *termGuid = termGuid_example; // Glossary term GUID (default to null)
array[AtlasRelatedObjectId] *atlasRelatedObjectId = [{"displayText":"...","entityStatus":"ACTIVE","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"ACTIVE","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}}]; //  (optional)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.GlossaryRESTApi()
var termGuid = termGuid_example; // {String} Glossary term GUID
var opts = {
  'atlasRelatedObjectId': [{"displayText":"...","entityStatus":"ACTIVE","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"ACTIVE","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}}] // {array[AtlasRelatedObjectId]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new GlossaryRESTApi();
            var termGuid = termGuid_example;  // String | Glossary term GUID (default to null)
            var atlasRelatedObjectId = new array[AtlasRelatedObjectId](); // array[AtlasRelatedObjectId] |  (optional) 

            try {
                apiInstance.assignTermToEntities(termGuid, atlasRelatedObjectId);
            } catch (Exception e) {
                Debug.Print("Exception when calling GlossaryRESTApi.assignTermToEntities: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GlossaryRESTApi();
$termGuid = termGuid_example; // String | Glossary term GUID
$atlasRelatedObjectId = [{"displayText":"...","entityStatus":"ACTIVE","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"ACTIVE","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}}]; // array[AtlasRelatedObjectId] | 

try {
    $api_instance->assignTermToEntities($termGuid, $atlasRelatedObjectId);
} catch (Exception $e) {
    echo 'Exception when calling GlossaryRESTApi->assignTermToEntities: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GlossaryRESTApi->new();
my $termGuid = termGuid_example; # String | Glossary term GUID
my $atlasRelatedObjectId = [WWW::OPenAPIClient::Object::array[AtlasRelatedObjectId]->new()]; # array[AtlasRelatedObjectId] | 

eval {
    $api_instance->assignTermToEntities(termGuid => $termGuid, atlasRelatedObjectId => $atlasRelatedObjectId);
};
if ($@) {
    warn "Exception when calling GlossaryRESTApi->assignTermToEntities: $@\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.GlossaryRESTApi()
termGuid = termGuid_example # String | Glossary term GUID (default to null)
atlasRelatedObjectId = [{"displayText":"...","entityStatus":"ACTIVE","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"ACTIVE","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}}] # array[AtlasRelatedObjectId] |  (optional)

try:
    api_instance.assign_term_to_entities(termGuid, atlasRelatedObjectId=atlasRelatedObjectId)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->assignTermToEntities: %s\n" % e)

extern crate GlossaryRESTApi;

pub fn main() {
    let termGuid = termGuid_example; // String
    let atlasRelatedObjectId = [{"displayText":"...","entityStatus":"ACTIVE","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"ACTIVE","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}}]; // array[AtlasRelatedObjectId]

    let mut context = GlossaryRESTApi::Context::default();
    let result = client.assignTermToEntities(termGuid, atlasRelatedObjectId, &context).wait();

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

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

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

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

        // Create an instance of the API class
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        AtlasGlossary atlasGlossary = {"categories":[{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."}],"language":"...","terms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."}],"usage":"...","additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."}; // AtlasGlossary | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final AtlasGlossary atlasGlossary = new AtlasGlossary(); // AtlasGlossary | 

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

import org.openapitools.client.api.GlossaryRESTApi;

public class GlossaryRESTApiExample {
    public static void main(String[] args) {
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        AtlasGlossary atlasGlossary = {"categories":[{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."}],"language":"...","terms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."}],"usage":"...","additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."}; // AtlasGlossary | 

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

// Create an instance of the API class
GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];
AtlasGlossary *atlasGlossary = {"categories":[{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."}],"language":"...","terms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."}],"usage":"...","additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."}; //  (optional)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.GlossaryRESTApi()
var opts = {
  'atlasGlossary': {"categories":[{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."}],"language":"...","terms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."}],"usage":"...","additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."} // {AtlasGlossary} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new GlossaryRESTApi();
            var atlasGlossary = new AtlasGlossary(); // AtlasGlossary |  (optional) 

            try {
                apiInstance.createGlossary(atlasGlossary);
            } catch (Exception e) {
                Debug.Print("Exception when calling GlossaryRESTApi.createGlossary: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GlossaryRESTApi();
$atlasGlossary = {"categories":[{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."}],"language":"...","terms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."}],"usage":"...","additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."}; // AtlasGlossary | 

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

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

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

eval {
    $api_instance->createGlossary(atlasGlossary => $atlasGlossary);
};
if ($@) {
    warn "Exception when calling GlossaryRESTApi->createGlossary: $@\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.GlossaryRESTApi()
atlasGlossary = {"categories":[{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."}],"language":"...","terms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."}],"usage":"...","additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."} # AtlasGlossary |  (optional)

try:
    api_instance.create_glossary(atlasGlossary=atlasGlossary)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->createGlossary: %s\n" % e)

extern crate GlossaryRESTApi;

pub fn main() {
    let atlasGlossary = {"categories":[{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."}],"language":"...","terms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."}],"usage":"...","additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."}; // AtlasGlossary

    let mut context = GlossaryRESTApi::Context::default();
    let result = client.createGlossary(atlasGlossary, &context).wait();

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

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

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

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

        // Create an instance of the API class
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        array[AtlasGlossaryCategory] atlasGlossaryCategory = [{"anchor":{"displayText":"...","glossaryGuid":"...","relationGuid":"..."},"childrenCategories":[{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."}],"parentCategory":{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},"terms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."}]; // array[AtlasGlossaryCategory] | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[AtlasGlossaryCategory] atlasGlossaryCategory = new array[AtlasGlossaryCategory](); // array[AtlasGlossaryCategory] | 

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

import org.openapitools.client.api.GlossaryRESTApi;

public class GlossaryRESTApiExample {
    public static void main(String[] args) {
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        array[AtlasGlossaryCategory] atlasGlossaryCategory = [{"anchor":{"displayText":"...","glossaryGuid":"...","relationGuid":"..."},"childrenCategories":[{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."}],"parentCategory":{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},"terms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."}]; // array[AtlasGlossaryCategory] | 

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

// Create an instance of the API class
GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];
array[AtlasGlossaryCategory] *atlasGlossaryCategory = [{"anchor":{"displayText":"...","glossaryGuid":"...","relationGuid":"..."},"childrenCategories":[{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."}],"parentCategory":{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},"terms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."}]; //  (optional)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.GlossaryRESTApi()
var opts = {
  'atlasGlossaryCategory': [{"anchor":{"displayText":"...","glossaryGuid":"...","relationGuid":"..."},"childrenCategories":[{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."}],"parentCategory":{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},"terms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."}] // {array[AtlasGlossaryCategory]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new GlossaryRESTApi();
            var atlasGlossaryCategory = new array[AtlasGlossaryCategory](); // array[AtlasGlossaryCategory] |  (optional) 

            try {
                apiInstance.createGlossaryCategories(atlasGlossaryCategory);
            } catch (Exception e) {
                Debug.Print("Exception when calling GlossaryRESTApi.createGlossaryCategories: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GlossaryRESTApi();
$atlasGlossaryCategory = [{"anchor":{"displayText":"...","glossaryGuid":"...","relationGuid":"..."},"childrenCategories":[{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."}],"parentCategory":{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},"terms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."}]; // array[AtlasGlossaryCategory] | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GlossaryRESTApi->new();
my $atlasGlossaryCategory = [WWW::OPenAPIClient::Object::array[AtlasGlossaryCategory]->new()]; # array[AtlasGlossaryCategory] | 

eval {
    $api_instance->createGlossaryCategories(atlasGlossaryCategory => $atlasGlossaryCategory);
};
if ($@) {
    warn "Exception when calling GlossaryRESTApi->createGlossaryCategories: $@\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.GlossaryRESTApi()
atlasGlossaryCategory = [{"anchor":{"displayText":"...","glossaryGuid":"...","relationGuid":"..."},"childrenCategories":[{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."}],"parentCategory":{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},"terms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."}] # array[AtlasGlossaryCategory] |  (optional)

try:
    api_instance.create_glossary_categories(atlasGlossaryCategory=atlasGlossaryCategory)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->createGlossaryCategories: %s\n" % e)

extern crate GlossaryRESTApi;

pub fn main() {
    let atlasGlossaryCategory = [{"anchor":{"displayText":"...","glossaryGuid":"...","relationGuid":"..."},"childrenCategories":[{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."}],"parentCategory":{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},"terms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."}]; // array[AtlasGlossaryCategory]

    let mut context = GlossaryRESTApi::Context::default();
    let result = client.createGlossaryCategories(atlasGlossaryCategory, &context).wait();

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

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

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

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

        // Create an instance of the API class
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        AtlasGlossaryCategory atlasGlossaryCategory = {"anchor":{"displayText":"...","glossaryGuid":"...","relationGuid":"..."},"childrenCategories":[{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."}],"parentCategory":{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},"terms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."}; // AtlasGlossaryCategory | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final AtlasGlossaryCategory atlasGlossaryCategory = new AtlasGlossaryCategory(); // AtlasGlossaryCategory | 

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

import org.openapitools.client.api.GlossaryRESTApi;

public class GlossaryRESTApiExample {
    public static void main(String[] args) {
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        AtlasGlossaryCategory atlasGlossaryCategory = {"anchor":{"displayText":"...","glossaryGuid":"...","relationGuid":"..."},"childrenCategories":[{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."}],"parentCategory":{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},"terms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."}; // AtlasGlossaryCategory | 

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

// Create an instance of the API class
GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];
AtlasGlossaryCategory *atlasGlossaryCategory = {"anchor":{"displayText":"...","glossaryGuid":"...","relationGuid":"..."},"childrenCategories":[{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."}],"parentCategory":{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},"terms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."}; //  (optional)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.GlossaryRESTApi()
var opts = {
  'atlasGlossaryCategory': {"anchor":{"displayText":"...","glossaryGuid":"...","relationGuid":"..."},"childrenCategories":[{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."}],"parentCategory":{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},"terms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."} // {AtlasGlossaryCategory} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new GlossaryRESTApi();
            var atlasGlossaryCategory = new AtlasGlossaryCategory(); // AtlasGlossaryCategory |  (optional) 

            try {
                apiInstance.createGlossaryCategory(atlasGlossaryCategory);
            } catch (Exception e) {
                Debug.Print("Exception when calling GlossaryRESTApi.createGlossaryCategory: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GlossaryRESTApi();
$atlasGlossaryCategory = {"anchor":{"displayText":"...","glossaryGuid":"...","relationGuid":"..."},"childrenCategories":[{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."}],"parentCategory":{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},"terms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."}; // AtlasGlossaryCategory | 

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

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

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

eval {
    $api_instance->createGlossaryCategory(atlasGlossaryCategory => $atlasGlossaryCategory);
};
if ($@) {
    warn "Exception when calling GlossaryRESTApi->createGlossaryCategory: $@\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.GlossaryRESTApi()
atlasGlossaryCategory = {"anchor":{"displayText":"...","glossaryGuid":"...","relationGuid":"..."},"childrenCategories":[{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."}],"parentCategory":{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},"terms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."} # AtlasGlossaryCategory |  (optional)

try:
    api_instance.create_glossary_category(atlasGlossaryCategory=atlasGlossaryCategory)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->createGlossaryCategory: %s\n" % e)

extern crate GlossaryRESTApi;

pub fn main() {
    let atlasGlossaryCategory = {"anchor":{"displayText":"...","glossaryGuid":"...","relationGuid":"..."},"childrenCategories":[{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."}],"parentCategory":{"categoryGuid":"...","description":"...","displayText":"...","parentCategoryGuid":"...","relationGuid":"..."},"terms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."}; // AtlasGlossaryCategory

    let mut context = GlossaryRESTApi::Context::default();
    let result = client.createGlossaryCategory(atlasGlossaryCategory, &context).wait();

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

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

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

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

        // Create an instance of the API class
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        AtlasGlossaryTerm atlasGlossaryTerm = {"abbreviation":"...","anchor":{"displayText":"...","glossaryGuid":"...","relationGuid":"..."},"antonyms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"assignedEntities":[{"displayText":"...","entityStatus":"ACTIVE","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"ACTIVE","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}},{"displayText":"...","entityStatus":"DELETED","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"DELETED","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}}],"categories":[{"categoryGuid":"...","description":"...","displayText":"...","relationGuid":"...","status":"OBSOLETE"},{"categoryGuid":"...","description":"...","displayText":"...","relationGuid":"...","status":"OBSOLETE"}],"classifies":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"examples":["...","..."],"glossaryTermHeader":{"qualifiedName":"...","termGuid":"..."},"isA":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"preferredTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"preferredToTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"replacedBy":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"replacementTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"seeAlso":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"synonyms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"translatedTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"translationTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"usage":"...","validValues":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"validValuesFor":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."}; // AtlasGlossaryTerm | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final AtlasGlossaryTerm atlasGlossaryTerm = new AtlasGlossaryTerm(); // AtlasGlossaryTerm | 

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

import org.openapitools.client.api.GlossaryRESTApi;

public class GlossaryRESTApiExample {
    public static void main(String[] args) {
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        AtlasGlossaryTerm atlasGlossaryTerm = {"abbreviation":"...","anchor":{"displayText":"...","glossaryGuid":"...","relationGuid":"..."},"antonyms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"assignedEntities":[{"displayText":"...","entityStatus":"ACTIVE","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"ACTIVE","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}},{"displayText":"...","entityStatus":"DELETED","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"DELETED","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}}],"categories":[{"categoryGuid":"...","description":"...","displayText":"...","relationGuid":"...","status":"OBSOLETE"},{"categoryGuid":"...","description":"...","displayText":"...","relationGuid":"...","status":"OBSOLETE"}],"classifies":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"examples":["...","..."],"glossaryTermHeader":{"qualifiedName":"...","termGuid":"..."},"isA":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"preferredTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"preferredToTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"replacedBy":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"replacementTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"seeAlso":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"synonyms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"translatedTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"translationTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"usage":"...","validValues":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"validValuesFor":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."}; // AtlasGlossaryTerm | 

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

// Create an instance of the API class
GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];
AtlasGlossaryTerm *atlasGlossaryTerm = {"abbreviation":"...","anchor":{"displayText":"...","glossaryGuid":"...","relationGuid":"..."},"antonyms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"assignedEntities":[{"displayText":"...","entityStatus":"ACTIVE","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"ACTIVE","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}},{"displayText":"...","entityStatus":"DELETED","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"DELETED","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}}],"categories":[{"categoryGuid":"...","description":"...","displayText":"...","relationGuid":"...","status":"OBSOLETE"},{"categoryGuid":"...","description":"...","displayText":"...","relationGuid":"...","status":"OBSOLETE"}],"classifies":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"examples":["...","..."],"glossaryTermHeader":{"qualifiedName":"...","termGuid":"..."},"isA":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"preferredTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"preferredToTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"replacedBy":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"replacementTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"seeAlso":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"synonyms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"translatedTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"translationTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"usage":"...","validValues":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"validValuesFor":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."}; //  (optional)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.GlossaryRESTApi()
var opts = {
  'atlasGlossaryTerm': {"abbreviation":"...","anchor":{"displayText":"...","glossaryGuid":"...","relationGuid":"..."},"antonyms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"assignedEntities":[{"displayText":"...","entityStatus":"ACTIVE","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"ACTIVE","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}},{"displayText":"...","entityStatus":"DELETED","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"DELETED","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}}],"categories":[{"categoryGuid":"...","description":"...","displayText":"...","relationGuid":"...","status":"OBSOLETE"},{"categoryGuid":"...","description":"...","displayText":"...","relationGuid":"...","status":"OBSOLETE"}],"classifies":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"examples":["...","..."],"glossaryTermHeader":{"qualifiedName":"...","termGuid":"..."},"isA":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"preferredTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"preferredToTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"replacedBy":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"replacementTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"seeAlso":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"synonyms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"translatedTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"translationTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"usage":"...","validValues":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"validValuesFor":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."} // {AtlasGlossaryTerm} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new GlossaryRESTApi();
            var atlasGlossaryTerm = new AtlasGlossaryTerm(); // AtlasGlossaryTerm |  (optional) 

            try {
                apiInstance.createGlossaryTerm(atlasGlossaryTerm);
            } catch (Exception e) {
                Debug.Print("Exception when calling GlossaryRESTApi.createGlossaryTerm: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GlossaryRESTApi();
$atlasGlossaryTerm = {"abbreviation":"...","anchor":{"displayText":"...","glossaryGuid":"...","relationGuid":"..."},"antonyms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"assignedEntities":[{"displayText":"...","entityStatus":"ACTIVE","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"ACTIVE","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}},{"displayText":"...","entityStatus":"DELETED","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"DELETED","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}}],"categories":[{"categoryGuid":"...","description":"...","displayText":"...","relationGuid":"...","status":"OBSOLETE"},{"categoryGuid":"...","description":"...","displayText":"...","relationGuid":"...","status":"OBSOLETE"}],"classifies":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"examples":["...","..."],"glossaryTermHeader":{"qualifiedName":"...","termGuid":"..."},"isA":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"preferredTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"preferredToTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"replacedBy":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"replacementTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"seeAlso":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"synonyms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"translatedTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"translationTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"usage":"...","validValues":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"validValuesFor":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."}; // AtlasGlossaryTerm | 

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

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

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

eval {
    $api_instance->createGlossaryTerm(atlasGlossaryTerm => $atlasGlossaryTerm);
};
if ($@) {
    warn "Exception when calling GlossaryRESTApi->createGlossaryTerm: $@\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.GlossaryRESTApi()
atlasGlossaryTerm = {"abbreviation":"...","anchor":{"displayText":"...","glossaryGuid":"...","relationGuid":"..."},"antonyms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"assignedEntities":[{"displayText":"...","entityStatus":"ACTIVE","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"ACTIVE","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}},{"displayText":"...","entityStatus":"DELETED","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"DELETED","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}}],"categories":[{"categoryGuid":"...","description":"...","displayText":"...","relationGuid":"...","status":"OBSOLETE"},{"categoryGuid":"...","description":"...","displayText":"...","relationGuid":"...","status":"OBSOLETE"}],"classifies":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"examples":["...","..."],"glossaryTermHeader":{"qualifiedName":"...","termGuid":"..."},"isA":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"preferredTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"preferredToTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"replacedBy":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"replacementTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"seeAlso":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"synonyms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"translatedTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"translationTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"usage":"...","validValues":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"validValuesFor":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."} # AtlasGlossaryTerm |  (optional)

try:
    api_instance.create_glossary_term(atlasGlossaryTerm=atlasGlossaryTerm)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->createGlossaryTerm: %s\n" % e)

extern crate GlossaryRESTApi;

pub fn main() {
    let atlasGlossaryTerm = {"abbreviation":"...","anchor":{"displayText":"...","glossaryGuid":"...","relationGuid":"..."},"antonyms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"assignedEntities":[{"displayText":"...","entityStatus":"ACTIVE","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"ACTIVE","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}},{"displayText":"...","entityStatus":"DELETED","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"DELETED","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}}],"categories":[{"categoryGuid":"...","description":"...","displayText":"...","relationGuid":"...","status":"OBSOLETE"},{"categoryGuid":"...","description":"...","displayText":"...","relationGuid":"...","status":"OBSOLETE"}],"classifies":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"examples":["...","..."],"glossaryTermHeader":{"qualifiedName":"...","termGuid":"..."},"isA":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"preferredTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"preferredToTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"replacedBy":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"replacementTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"seeAlso":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"synonyms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"translatedTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"translationTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"usage":"...","validValues":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"validValuesFor":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"DELETED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."}; // AtlasGlossaryTerm

    let mut context = GlossaryRESTApi::Context::default();
    let result = client.createGlossaryTerm(atlasGlossaryTerm, &context).wait();

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

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

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

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

        // Create an instance of the API class
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        array[AtlasGlossaryTerm] atlasGlossaryTerm = [{"abbreviation":"...","anchor":{"displayText":"...","glossaryGuid":"...","relationGuid":"..."},"antonyms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"assignedEntities":[{"displayText":"...","entityStatus":"PURGED","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"ACTIVE","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}},{"displayText":"...","entityStatus":"PURGED","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"DELETED","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}}],"categories":[{"categoryGuid":"...","description":"...","displayText":"...","relationGuid":"...","status":"OTHER"},{"categoryGuid":"...","description":"...","displayText":"...","relationGuid":"...","status":"DEPRECATED"}],"classifies":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"examples":["...","..."],"glossaryTermHeader":{"qualifiedName":"...","termGuid":"..."},"isA":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"preferredTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."}],"preferredToTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"replacedBy":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"replacementTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"seeAlso":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"synonyms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"translatedTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"translationTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"usage":"...","validValues":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"validValuesFor":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."}]; // array[AtlasGlossaryTerm] | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[AtlasGlossaryTerm] atlasGlossaryTerm = new array[AtlasGlossaryTerm](); // array[AtlasGlossaryTerm] | 

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

import org.openapitools.client.api.GlossaryRESTApi;

public class GlossaryRESTApiExample {
    public static void main(String[] args) {
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        array[AtlasGlossaryTerm] atlasGlossaryTerm = [{"abbreviation":"...","anchor":{"displayText":"...","glossaryGuid":"...","relationGuid":"..."},"antonyms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"assignedEntities":[{"displayText":"...","entityStatus":"PURGED","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"ACTIVE","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}},{"displayText":"...","entityStatus":"PURGED","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"DELETED","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}}],"categories":[{"categoryGuid":"...","description":"...","displayText":"...","relationGuid":"...","status":"OTHER"},{"categoryGuid":"...","description":"...","displayText":"...","relationGuid":"...","status":"DEPRECATED"}],"classifies":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"examples":["...","..."],"glossaryTermHeader":{"qualifiedName":"...","termGuid":"..."},"isA":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"preferredTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."}],"preferredToTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"replacedBy":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"replacementTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"seeAlso":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"synonyms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"translatedTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"translationTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"usage":"...","validValues":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"validValuesFor":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."}]; // array[AtlasGlossaryTerm] | 

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

// Create an instance of the API class
GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];
array[AtlasGlossaryTerm] *atlasGlossaryTerm = [{"abbreviation":"...","anchor":{"displayText":"...","glossaryGuid":"...","relationGuid":"..."},"antonyms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"assignedEntities":[{"displayText":"...","entityStatus":"PURGED","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"ACTIVE","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}},{"displayText":"...","entityStatus":"PURGED","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"DELETED","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}}],"categories":[{"categoryGuid":"...","description":"...","displayText":"...","relationGuid":"...","status":"OTHER"},{"categoryGuid":"...","description":"...","displayText":"...","relationGuid":"...","status":"DEPRECATED"}],"classifies":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"examples":["...","..."],"glossaryTermHeader":{"qualifiedName":"...","termGuid":"..."},"isA":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"preferredTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."}],"preferredToTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"replacedBy":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"replacementTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"seeAlso":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"synonyms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"translatedTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"translationTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"usage":"...","validValues":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"validValuesFor":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."}]; //  (optional)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.GlossaryRESTApi()
var opts = {
  'atlasGlossaryTerm': [{"abbreviation":"...","anchor":{"displayText":"...","glossaryGuid":"...","relationGuid":"..."},"antonyms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"assignedEntities":[{"displayText":"...","entityStatus":"PURGED","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"ACTIVE","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}},{"displayText":"...","entityStatus":"PURGED","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"DELETED","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}}],"categories":[{"categoryGuid":"...","description":"...","displayText":"...","relationGuid":"...","status":"OTHER"},{"categoryGuid":"...","description":"...","displayText":"...","relationGuid":"...","status":"DEPRECATED"}],"classifies":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"examples":["...","..."],"glossaryTermHeader":{"qualifiedName":"...","termGuid":"..."},"isA":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"preferredTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."}],"preferredToTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"replacedBy":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"replacementTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"seeAlso":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"synonyms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"translatedTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"translationTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"usage":"...","validValues":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"validValuesFor":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."}] // {array[AtlasGlossaryTerm]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new GlossaryRESTApi();
            var atlasGlossaryTerm = new array[AtlasGlossaryTerm](); // array[AtlasGlossaryTerm] |  (optional) 

            try {
                apiInstance.createGlossaryTerms(atlasGlossaryTerm);
            } catch (Exception e) {
                Debug.Print("Exception when calling GlossaryRESTApi.createGlossaryTerms: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GlossaryRESTApi();
$atlasGlossaryTerm = [{"abbreviation":"...","anchor":{"displayText":"...","glossaryGuid":"...","relationGuid":"..."},"antonyms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"assignedEntities":[{"displayText":"...","entityStatus":"PURGED","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"ACTIVE","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}},{"displayText":"...","entityStatus":"PURGED","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"DELETED","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}}],"categories":[{"categoryGuid":"...","description":"...","displayText":"...","relationGuid":"...","status":"OTHER"},{"categoryGuid":"...","description":"...","displayText":"...","relationGuid":"...","status":"DEPRECATED"}],"classifies":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"examples":["...","..."],"glossaryTermHeader":{"qualifiedName":"...","termGuid":"..."},"isA":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"preferredTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."}],"preferredToTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"replacedBy":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"replacementTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"seeAlso":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"synonyms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"translatedTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"translationTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"usage":"...","validValues":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"validValuesFor":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."}]; // array[AtlasGlossaryTerm] | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GlossaryRESTApi->new();
my $atlasGlossaryTerm = [WWW::OPenAPIClient::Object::array[AtlasGlossaryTerm]->new()]; # array[AtlasGlossaryTerm] | 

eval {
    $api_instance->createGlossaryTerms(atlasGlossaryTerm => $atlasGlossaryTerm);
};
if ($@) {
    warn "Exception when calling GlossaryRESTApi->createGlossaryTerms: $@\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.GlossaryRESTApi()
atlasGlossaryTerm = [{"abbreviation":"...","anchor":{"displayText":"...","glossaryGuid":"...","relationGuid":"..."},"antonyms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"assignedEntities":[{"displayText":"...","entityStatus":"PURGED","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"ACTIVE","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}},{"displayText":"...","entityStatus":"PURGED","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"DELETED","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}}],"categories":[{"categoryGuid":"...","description":"...","displayText":"...","relationGuid":"...","status":"OTHER"},{"categoryGuid":"...","description":"...","displayText":"...","relationGuid":"...","status":"DEPRECATED"}],"classifies":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"examples":["...","..."],"glossaryTermHeader":{"qualifiedName":"...","termGuid":"..."},"isA":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"preferredTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."}],"preferredToTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"replacedBy":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"replacementTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"seeAlso":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"synonyms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"translatedTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"translationTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"usage":"...","validValues":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"validValuesFor":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."}] # array[AtlasGlossaryTerm] |  (optional)

try:
    api_instance.create_glossary_terms(atlasGlossaryTerm=atlasGlossaryTerm)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->createGlossaryTerms: %s\n" % e)

extern crate GlossaryRESTApi;

pub fn main() {
    let atlasGlossaryTerm = [{"abbreviation":"...","anchor":{"displayText":"...","glossaryGuid":"...","relationGuid":"..."},"antonyms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"assignedEntities":[{"displayText":"...","entityStatus":"PURGED","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"ACTIVE","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}},{"displayText":"...","entityStatus":"PURGED","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"DELETED","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}}],"categories":[{"categoryGuid":"...","description":"...","displayText":"...","relationGuid":"...","status":"OTHER"},{"categoryGuid":"...","description":"...","displayText":"...","relationGuid":"...","status":"DEPRECATED"}],"classifies":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"examples":["...","..."],"glossaryTermHeader":{"qualifiedName":"...","termGuid":"..."},"isA":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"preferredTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."}],"preferredToTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"replacedBy":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"ACTIVE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"replacementTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"seeAlso":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"synonyms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."}],"translatedTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"translationTerms":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OBSOLETE","steward":"...","termGuid":"..."}],"usage":"...","validValues":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"OTHER","steward":"...","termGuid":"..."}],"validValuesFor":[{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DRAFT","steward":"...","termGuid":"..."},{"description":"...","displayText":"...","expression":"...","qualifiedName":"...","relationGuid":"...","source":"...","status":"DEPRECATED","steward":"...","termGuid":"..."}],"additionalAttributes":{"property1":{},"property2":{}},"classifications":[{"entityGuid":"...","entityStatus":"ACTIVE","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."},{"entityGuid":"...","entityStatus":"PURGED","propagate":true,"removePropagationsOnEntityDelete":true,"validityPeriods":[{"endTime":"...","startTime":"...","timeZone":"..."},{"endTime":"...","startTime":"...","timeZone":"..."}],"attributes":{"property1":{},"property2":{}},"typeName":"..."}],"longDescription":"...","name":"...","qualifiedName":"...","shortDescription":"...","guid":"..."}]; // array[AtlasGlossaryTerm]

    let mut context = GlossaryRESTApi::Context::default();
    let result = client.createGlossaryTerms(atlasGlossaryTerm, &context).wait();

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

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

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

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

        // Create an instance of the API class
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String glossaryGuid = glossaryGuid_example; // String | unique identifier for glossary

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String glossaryGuid = new String(); // String | unique identifier for glossary

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

import org.openapitools.client.api.GlossaryRESTApi;

public class GlossaryRESTApiExample {
    public static void main(String[] args) {
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String glossaryGuid = glossaryGuid_example; // String | unique identifier for glossary

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

// Create an instance of the API class
GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];
String *glossaryGuid = glossaryGuid_example; // unique identifier for glossary (default to null)

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

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.GlossaryRESTApi()
var glossaryGuid = glossaryGuid_example; // {String} unique identifier for glossary

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

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

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

            // Create an instance of the API class
            var apiInstance = new GlossaryRESTApi();
            var glossaryGuid = glossaryGuid_example;  // String | unique identifier for glossary (default to null)

            try {
                apiInstance.deleteGlossary(glossaryGuid);
            } catch (Exception e) {
                Debug.Print("Exception when calling GlossaryRESTApi.deleteGlossary: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GlossaryRESTApi();
$glossaryGuid = glossaryGuid_example; // String | unique identifier for glossary

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GlossaryRESTApi->new();
my $glossaryGuid = glossaryGuid_example; # String | unique identifier for glossary

eval {
    $api_instance->deleteGlossary(glossaryGuid => $glossaryGuid);
};
if ($@) {
    warn "Exception when calling GlossaryRESTApi->deleteGlossary: $@\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.GlossaryRESTApi()
glossaryGuid = glossaryGuid_example # String | unique identifier for glossary (default to null)

try:
    api_instance.delete_glossary(glossaryGuid)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->deleteGlossary: %s\n" % e)

extern crate GlossaryRESTApi;

pub fn main() {
    let glossaryGuid = glossaryGuid_example; // String

    let mut context = GlossaryRESTApi::Context::default();
    let result = client.deleteGlossary(glossaryGuid, &context).wait();

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

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

import java.io.File;
import java.util.*;

public class GlossaryRESTApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String categoryGuid = categoryGuid_example; // String | unique identifier for glossary category

        try {
            apiInstance.deleteGlossaryCategory(categoryGuid);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#deleteGlossaryCategory");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String categoryGuid = new String(); // String | unique identifier for glossary category

try {
    final result = await api_instance.deleteGlossaryCategory(categoryGuid);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteGlossaryCategory: $e\n');
}

import org.openapitools.client.api.GlossaryRESTApi;

public class GlossaryRESTApiExample {
    public static void main(String[] args) {
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String categoryGuid = categoryGuid_example; // String | unique identifier for glossary category

        try {
            apiInstance.deleteGlossaryCategory(categoryGuid);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#deleteGlossaryCategory");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];
String *categoryGuid = categoryGuid_example; // unique identifier for glossary category (default to null)

[apiInstance deleteGlossaryCategoryWith:categoryGuid
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.GlossaryRESTApi()
var categoryGuid = categoryGuid_example; // {String} unique identifier for glossary category

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteGlossaryCategory(categoryGuid, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class deleteGlossaryCategoryExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GlossaryRESTApi();
            var categoryGuid = categoryGuid_example;  // String | unique identifier for glossary category (default to null)

            try {
                apiInstance.deleteGlossaryCategory(categoryGuid);
            } catch (Exception e) {
                Debug.Print("Exception when calling GlossaryRESTApi.deleteGlossaryCategory: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GlossaryRESTApi();
$categoryGuid = categoryGuid_example; // String | unique identifier for glossary category

try {
    $api_instance->deleteGlossaryCategory($categoryGuid);
} catch (Exception $e) {
    echo 'Exception when calling GlossaryRESTApi->deleteGlossaryCategory: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GlossaryRESTApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GlossaryRESTApi->new();
my $categoryGuid = categoryGuid_example; # String | unique identifier for glossary category

eval {
    $api_instance->deleteGlossaryCategory(categoryGuid => $categoryGuid);
};
if ($@) {
    warn "Exception when calling GlossaryRESTApi->deleteGlossaryCategory: $@\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.GlossaryRESTApi()
categoryGuid = categoryGuid_example # String | unique identifier for glossary category (default to null)

try:
    api_instance.delete_glossary_category(categoryGuid)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->deleteGlossaryCategory: %s\n" % e)

extern crate GlossaryRESTApi;

pub fn main() {
    let categoryGuid = categoryGuid_example; // String

    let mut context = GlossaryRESTApi::Context::default();
    let result = client.deleteGlossaryCategory(categoryGuid, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GlossaryRESTApi;

import java.io.File;
import java.util.*;

public class GlossaryRESTApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String termGuid = termGuid_example; // String | unique identifier for glossary term

        try {
            apiInstance.deleteGlossaryTerm(termGuid);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#deleteGlossaryTerm");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String termGuid = new String(); // String | unique identifier for glossary term

try {
    final result = await api_instance.deleteGlossaryTerm(termGuid);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteGlossaryTerm: $e\n');
}

import org.openapitools.client.api.GlossaryRESTApi;

public class GlossaryRESTApiExample {
    public static void main(String[] args) {
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String termGuid = termGuid_example; // String | unique identifier for glossary term

        try {
            apiInstance.deleteGlossaryTerm(termGuid);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#deleteGlossaryTerm");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];
String *termGuid = termGuid_example; // unique identifier for glossary term (default to null)

[apiInstance deleteGlossaryTermWith:termGuid
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.GlossaryRESTApi()
var termGuid = termGuid_example; // {String} unique identifier for glossary term

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteGlossaryTerm(termGuid, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class deleteGlossaryTermExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GlossaryRESTApi();
            var termGuid = termGuid_example;  // String | unique identifier for glossary term (default to null)

            try {
                apiInstance.deleteGlossaryTerm(termGuid);
            } catch (Exception e) {
                Debug.Print("Exception when calling GlossaryRESTApi.deleteGlossaryTerm: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GlossaryRESTApi();
$termGuid = termGuid_example; // String | unique identifier for glossary term

try {
    $api_instance->deleteGlossaryTerm($termGuid);
} catch (Exception $e) {
    echo 'Exception when calling GlossaryRESTApi->deleteGlossaryTerm: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GlossaryRESTApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GlossaryRESTApi->new();
my $termGuid = termGuid_example; # String | unique identifier for glossary term

eval {
    $api_instance->deleteGlossaryTerm(termGuid => $termGuid);
};
if ($@) {
    warn "Exception when calling GlossaryRESTApi->deleteGlossaryTerm: $@\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.GlossaryRESTApi()
termGuid = termGuid_example # String | unique identifier for glossary term (default to null)

try:
    api_instance.delete_glossary_term(termGuid)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->deleteGlossaryTerm: %s\n" % e)

extern crate GlossaryRESTApi;

pub fn main() {
    let termGuid = termGuid_example; // String

    let mut context = GlossaryRESTApi::Context::default();
    let result = client.deleteGlossaryTerm(termGuid, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GlossaryRESTApi;

import java.io.File;
import java.util.*;

public class GlossaryRESTApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String termGuid = termGuid_example; // String | Glossary term GUID
        array[AtlasRelatedObjectId] atlasRelatedObjectId = [{"displayText":"...","entityStatus":"PURGED","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"DELETED","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}}]; // array[AtlasRelatedObjectId] | 

        try {
            apiInstance.disassociateTermAssignmentFromEntities(termGuid, atlasRelatedObjectId);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#disassociateTermAssignmentFromEntities");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String termGuid = new String(); // String | Glossary term GUID
final array[AtlasRelatedObjectId] atlasRelatedObjectId = new array[AtlasRelatedObjectId](); // array[AtlasRelatedObjectId] | 

try {
    final result = await api_instance.disassociateTermAssignmentFromEntities(termGuid, atlasRelatedObjectId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->disassociateTermAssignmentFromEntities: $e\n');
}

import org.openapitools.client.api.GlossaryRESTApi;

public class GlossaryRESTApiExample {
    public static void main(String[] args) {
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String termGuid = termGuid_example; // String | Glossary term GUID
        array[AtlasRelatedObjectId] atlasRelatedObjectId = [{"displayText":"...","entityStatus":"PURGED","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"DELETED","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}}]; // array[AtlasRelatedObjectId] | 

        try {
            apiInstance.disassociateTermAssignmentFromEntities(termGuid, atlasRelatedObjectId);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#disassociateTermAssignmentFromEntities");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];
String *termGuid = termGuid_example; // Glossary term GUID (default to null)
array[AtlasRelatedObjectId] *atlasRelatedObjectId = [{"displayText":"...","entityStatus":"PURGED","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"DELETED","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}}]; //  (optional)

[apiInstance disassociateTermAssignmentFromEntitiesWith:termGuid
    atlasRelatedObjectId:atlasRelatedObjectId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var AtlasRestApi = require('atlas_rest_api');

// Create an instance of the API class
var api = new AtlasRestApi.GlossaryRESTApi()
var termGuid = termGuid_example; // {String} Glossary term GUID
var opts = {
  'atlasRelatedObjectId': [{"displayText":"...","entityStatus":"PURGED","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"DELETED","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}}] // {array[AtlasRelatedObjectId]} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.disassociateTermAssignmentFromEntities(termGuid, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class disassociateTermAssignmentFromEntitiesExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GlossaryRESTApi();
            var termGuid = termGuid_example;  // String | Glossary term GUID (default to null)
            var atlasRelatedObjectId = new array[AtlasRelatedObjectId](); // array[AtlasRelatedObjectId] |  (optional) 

            try {
                apiInstance.disassociateTermAssignmentFromEntities(termGuid, atlasRelatedObjectId);
            } catch (Exception e) {
                Debug.Print("Exception when calling GlossaryRESTApi.disassociateTermAssignmentFromEntities: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GlossaryRESTApi();
$termGuid = termGuid_example; // String | Glossary term GUID
$atlasRelatedObjectId = [{"displayText":"...","entityStatus":"PURGED","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"DELETED","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}}]; // array[AtlasRelatedObjectId] | 

try {
    $api_instance->disassociateTermAssignmentFromEntities($termGuid, $atlasRelatedObjectId);
} catch (Exception $e) {
    echo 'Exception when calling GlossaryRESTApi->disassociateTermAssignmentFromEntities: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GlossaryRESTApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GlossaryRESTApi->new();
my $termGuid = termGuid_example; # String | Glossary term GUID
my $atlasRelatedObjectId = [WWW::OPenAPIClient::Object::array[AtlasRelatedObjectId]->new()]; # array[AtlasRelatedObjectId] | 

eval {
    $api_instance->disassociateTermAssignmentFromEntities(termGuid => $termGuid, atlasRelatedObjectId => $atlasRelatedObjectId);
};
if ($@) {
    warn "Exception when calling GlossaryRESTApi->disassociateTermAssignmentFromEntities: $@\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.GlossaryRESTApi()
termGuid = termGuid_example # String | Glossary term GUID (default to null)
atlasRelatedObjectId = [{"displayText":"...","entityStatus":"PURGED","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"DELETED","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}}] # array[AtlasRelatedObjectId] |  (optional)

try:
    api_instance.disassociate_term_assignment_from_entities(termGuid, atlasRelatedObjectId=atlasRelatedObjectId)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->disassociateTermAssignmentFromEntities: %s\n" % e)

extern crate GlossaryRESTApi;

pub fn main() {
    let termGuid = termGuid_example; // String
    let atlasRelatedObjectId = [{"displayText":"...","entityStatus":"PURGED","qualifiedName":"...","relationshipAttributes":{"attributes":{"property1":{},"property2":{}},"typeName":"..."},"relationshipGuid":"...","relationshipStatus":"DELETED","relationshipType":"...","guid":"...","typeName":"...","uniqueAttributes":{"property1":{},"property2":{}}}]; // array[AtlasRelatedObjectId]

    let mut context = GlossaryRESTApi::Context::default();
    let result = client.disassociateTermAssignmentFromEntities(termGuid, atlasRelatedObjectId, &context).wait();

    println!("{:?}", result);
}