Atlas REST API

DiscoveryREST

addSavedSearch

/v2/search/saved

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/api/atlas//v2/search/saved"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiscoveryRESTApi;

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

public class DiscoveryRESTApiExample {

    public static void main(String[] args) {
        
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        AtlasUserSavedSearch body = ; // AtlasUserSavedSearch | 
        try {
            AtlasUserSavedSearch result = apiInstance.addSavedSearch(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#addSavedSearch");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DiscoveryRESTApi;

public class DiscoveryRESTApiExample {

    public static void main(String[] args) {
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        AtlasUserSavedSearch body = ; // AtlasUserSavedSearch | 
        try {
            AtlasUserSavedSearch result = apiInstance.addSavedSearch(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#addSavedSearch");
            e.printStackTrace();
        }
    }
}

AtlasUserSavedSearch *body = ; //  (optional)

DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.DiscoveryRESTApi()
var opts = { 
  'body':  // {{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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new DiscoveryRESTApi();
            var body = new AtlasUserSavedSearch(); // AtlasUserSavedSearch |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiDiscoveryRESTApi();
$body = ; // AtlasUserSavedSearch | 

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

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

my $api_instance = WWW::SwaggerClient::DiscoveryRESTApi->new();
my $body = WWW::SwaggerClient::Object::AtlasUserSavedSearch->new(); # AtlasUserSavedSearch | 

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

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

# create an instance of the API class
api_instance = swagger_client.DiscoveryRESTApi()
body =  # AtlasUserSavedSearch |  (optional)

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

Parameters

Body parameters

Name	Description
body

Responses

Status: 201 - the saved search-object

Schema

basicSearchCreateFile

/v2/search/basic/download/create_file

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json"\
"/api/atlas//v2/search/basic/download/create_file"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiscoveryRESTApi;

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

public class DiscoveryRESTApiExample {

    public static void main(String[] args) {
        
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        map[String, Object] body = ; // map[String, Object] | 
        try {
            apiInstance.basicSearchCreateFile(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#basicSearchCreateFile");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DiscoveryRESTApi;

public class DiscoveryRESTApiExample {

    public static void main(String[] args) {
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        map[String, Object] body = ; // map[String, Object] | 
        try {
            apiInstance.basicSearchCreateFile(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#basicSearchCreateFile");
            e.printStackTrace();
        }
    }
}

map[String, Object] *body = ; //  (optional)

DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.DiscoveryRESTApi()
var opts = { 
  'body':  // {{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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new DiscoveryRESTApi();
            var body = new map[String, Object](); // map[String, Object] |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiDiscoveryRESTApi();
$body = ; // map[String, Object] | 

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

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

my $api_instance = WWW::SwaggerClient::DiscoveryRESTApi->new();
my $body = WWW::SwaggerClient::Object::map[String, Object]->new(); # map[String, Object] | 

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

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

# create an instance of the API class
api_instance = swagger_client.DiscoveryRESTApi()
body =  # map[String, Object] |  (optional)

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

Parameters

Body parameters

Name	Description
body

Responses

Status: 201 - Success

deleteSavedSearch

/v2/search/saved/{guid}

Usage and SDK Samples

curl -X DELETE\
"/api/atlas//v2/search/saved/{guid}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiscoveryRESTApi;

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

String *guid = guid_example; // Name of the saved search

DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new DiscoveryRESTApi();
            var guid = guid_example;  // String | Name of the saved search

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

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

$api_instance = new Swagger\Client\ApiDiscoveryRESTApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::DiscoveryRESTApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DiscoveryRESTApi()
guid = guid_example # String | Name of the saved search

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

Parameters

Path parameters

Name	Description
guid*	String Name of the saved search Required

Responses

Status: 204 - Success

downloadSearchResultFile

/v2/search/download/{filename}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/octet-stream"\
"/api/atlas//v2/search/download/{filename}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiscoveryRESTApi;

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

public class DiscoveryRESTApiExample {

    public static void main(String[] args) {
        
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        String filename = filename_example; // String | 
        try {
            byte[] result = apiInstance.downloadSearchResultFile(filename);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#downloadSearchResultFile");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DiscoveryRESTApi;

public class DiscoveryRESTApiExample {

    public static void main(String[] args) {
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        String filename = filename_example; // String | 
        try {
            byte[] result = apiInstance.downloadSearchResultFile(filename);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#downloadSearchResultFile");
            e.printStackTrace();
        }
    }
}

String *filename = filename_example; // 

DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new DiscoveryRESTApi();
            var filename = filename_example;  // String | 

            try
            {
                byte[] 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');

$api_instance = new Swagger\Client\ApiDiscoveryRESTApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::DiscoveryRESTApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DiscoveryRESTApi()
filename = filename_example # String | 

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)

Parameters

Path parameters

Name	Description
filename*	String Required

Responses

Status: 200 -

Schema

dslSearchCreateFile

/v2/search/dsl/download/create_file

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json"\
"/api/atlas//v2/search/dsl/download/create_file"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiscoveryRESTApi;

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

public class DiscoveryRESTApiExample {

    public static void main(String[] args) {
        
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        map[String, Object] body = ; // map[String, Object] | 
        try {
            apiInstance.dslSearchCreateFile(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#dslSearchCreateFile");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DiscoveryRESTApi;

public class DiscoveryRESTApiExample {

    public static void main(String[] args) {
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        map[String, Object] body = ; // map[String, Object] | 
        try {
            apiInstance.dslSearchCreateFile(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#dslSearchCreateFile");
            e.printStackTrace();
        }
    }
}

map[String, Object] *body = ; //  (optional)

DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.DiscoveryRESTApi()
var opts = { 
  'body':  // {{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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new DiscoveryRESTApi();
            var body = new map[String, Object](); // map[String, Object] |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiDiscoveryRESTApi();
$body = ; // map[String, Object] | 

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

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

my $api_instance = WWW::SwaggerClient::DiscoveryRESTApi->new();
my $body = WWW::SwaggerClient::Object::map[String, Object]->new(); # map[String, Object] | 

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

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

# create an instance of the API class
api_instance = swagger_client.DiscoveryRESTApi()
body =  # map[String, Object] |  (optional)

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

Parameters

Body parameters

Name	Description
body

Responses

Status: 201 - Success

executeSavedSearchByGuid

Attribute based search for entities satisfying the search parameters

/v2/search/saved/execute/guid/{guid}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/search/saved/execute/guid/{guid}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiscoveryRESTApi;

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

String *guid = guid_example; // Guid identifying saved search

DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new DiscoveryRESTApi();
            var guid = guid_example;  // String | Guid identifying saved search

            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');

$api_instance = new Swagger\Client\ApiDiscoveryRESTApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::DiscoveryRESTApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DiscoveryRESTApi()
guid = guid_example # String | Guid identifying saved search

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)

Parameters

Path parameters

Name	Description
guid*	String Guid identifying saved search Required

Responses

Status: 200 - Atlas search result

Schema

executeSavedSearchByName

Attribute based search for entities satisfying the search parameters

/v2/search/saved/execute/{name}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/search/saved/execute/{name}?user="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiscoveryRESTApi;

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

String *name = name_example; // name of saved-search
String *user = user_example; // saved-search owner (optional)

DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];

[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');

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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new DiscoveryRESTApi();
            var name = name_example;  // String | name of saved-search
            var user = user_example;  // String | saved-search owner (optional) 

            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');

$api_instance = new Swagger\Client\ApiDiscoveryRESTApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::DiscoveryRESTApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DiscoveryRESTApi()
name = name_example # String | name of saved-search
user = user_example # String | saved-search owner (optional)

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)

Parameters

Path parameters

Name	Description
name*	String name of saved-search Required

Query parameters

Name	Description
user	String saved-search owner

Responses

Status: 200 - Atlas search result

Schema

getSavedSearch

/v2/search/saved/{name}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/search/saved/{name}?user="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiscoveryRESTApi;

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

String *name = name_example; // Name of the saved search
String *user = user_example; // User for whom the search is retrieved (optional)

DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];

[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');

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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new DiscoveryRESTApi();
            var name = name_example;  // String | Name of the saved search
            var user = user_example;  // String | User for whom the search is retrieved (optional) 

            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');

$api_instance = new Swagger\Client\ApiDiscoveryRESTApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::DiscoveryRESTApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DiscoveryRESTApi()
name = name_example # String | Name of the saved search
user = user_example # String | User for whom the search is retrieved (optional)

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)

Parameters

Path parameters

Name	Description
name*	String Name of the saved search Required

Query parameters

Name	Description
user	String User for whom the search is retrieved

Responses

Status: 200 -

Schema

getSavedSearches

/v2/search/saved

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/search/saved?user="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiscoveryRESTApi;

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

String *user = user_example; // User for whom the search is retrieved (optional)

DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new DiscoveryRESTApi();
            var user = user_example;  // String | User for whom the search is retrieved (optional) 

            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');

$api_instance = new Swagger\Client\ApiDiscoveryRESTApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::DiscoveryRESTApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DiscoveryRESTApi()
user = user_example # String | User for whom the search is retrieved (optional)

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)

Parameters

Query parameters

Name	Description
user	String User for whom the search is retrieved

Responses

Status: 200 - list of all saved searches for given user

Schema

getSearchResultDownloadStatus

/v2/search/download/status

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/search/download/status"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiscoveryRESTApi;

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}


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');

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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            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');

$api_instance = new Swagger\Client\ApiDiscoveryRESTApi();

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::SwaggerClient::Configuration;
use WWW::SwaggerClient::DiscoveryRESTApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_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)

Parameters

Responses

Status: 200 -

Schema

getSuggestions

/v2/search/suggestions

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/search/suggestions?fieldName=&prefixString="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiscoveryRESTApi;

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

String *fieldName = fieldName_example; //  (optional)
String *prefixString = prefixString_example; //  (optional)

DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];

[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');

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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new DiscoveryRESTApi();
            var fieldName = fieldName_example;  // String |  (optional) 
            var prefixString = prefixString_example;  // String |  (optional) 

            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');

$api_instance = new Swagger\Client\ApiDiscoveryRESTApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::DiscoveryRESTApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DiscoveryRESTApi()
fieldName = fieldName_example # String |  (optional)
prefixString = prefixString_example # String |  (optional)

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)

Parameters

Query parameters

Name	Description
fieldName	String
prefixString	String

Responses

Status: 200 -

Schema

quickSearch

Attribute based search for entities satisfying the search parameters

/v2/search/quick

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/search/quick?excludeDeletedEntities=&limit=&offset=&query=&sortBy=&sortOrder=&typeName="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiscoveryRESTApi;

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

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 {
            AtlasQuickSearchResult result = apiInstance.quickSearch(excludeDeletedEntities, limit, offset, query, sortBy, sortOrder, typeName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#quickSearch");
            e.printStackTrace();
        }
    }
}

import io.swagger.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 {
            AtlasQuickSearchResult result = apiInstance.quickSearch(excludeDeletedEntities, limit, offset, query, sortBy, sortOrder, typeName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#quickSearch");
            e.printStackTrace();
        }
    }
}

Boolean *excludeDeletedEntities = true; // 
Integer *limit = 56; // 
Integer *offset = 56; // 
String *query = query_example; //  (optional)
String *sortBy = sortBy_example; //  (optional)
String *sortOrder = sortOrder_example; //  (optional)
String *typeName = typeName_example; //  (optional)

DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

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. Returned data: ' + data);
  }
};
api.quickSearch(excludeDeletedEntities, limit, offset, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new DiscoveryRESTApi();
            var excludeDeletedEntities = true;  // Boolean | 
            var limit = 56;  // Integer | 
            var offset = 56;  // Integer | 
            var query = query_example;  // String |  (optional) 
            var sortBy = sortBy_example;  // String |  (optional) 
            var sortOrder = sortOrder_example;  // String |  (optional) 
            var typeName = typeName_example;  // String |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiDiscoveryRESTApi();
$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 {
    $result = $api_instance->quickSearch($excludeDeletedEntities, $limit, $offset, $query, $sortBy, $sortOrder, $typeName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DiscoveryRESTApi->quickSearch: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::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 { 
    my $result = $api_instance->quickSearch(excludeDeletedEntities => $excludeDeletedEntities, limit => $limit, offset => $offset, query => $query, sortBy => $sortBy, sortOrder => $sortOrder, typeName => $typeName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DiscoveryRESTApi->quickSearch: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.DiscoveryRESTApi()
excludeDeletedEntities = true # Boolean | 
limit = 56 # Integer | 
offset = 56 # Integer | 
query = query_example # String |  (optional)
sortBy = sortBy_example # String |  (optional)
sortOrder = sortOrder_example # String |  (optional)
typeName = typeName_example # String |  (optional)

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

Parameters

Query parameters

Name	Description
excludeDeletedEntities*	Boolean Required
limit*	Integer (int32) Required
offset*	Integer (int32) Required
query	String
sortBy	String
sortOrder	String
typeName	String

Responses

Status: 200 - On successful search

Schema

Status: 400 - Tag/Entity doesn't exist or Tag/entity filter is present without tag/type name

quickSearch2

Attribute based search for entities satisfying the search parameters

/v2/search/quick

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/api/atlas//v2/search/quick"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiscoveryRESTApi;

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

public class DiscoveryRESTApiExample {

    public static void main(String[] args) {
        
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        QuickSearchParameters body = ; // QuickSearchParameters | 
        try {
            AtlasQuickSearchResult result = apiInstance.quickSearch2(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#quickSearch2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DiscoveryRESTApi;

public class DiscoveryRESTApiExample {

    public static void main(String[] args) {
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        QuickSearchParameters body = ; // QuickSearchParameters | 
        try {
            AtlasQuickSearchResult result = apiInstance.quickSearch2(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#quickSearch2");
            e.printStackTrace();
        }
    }
}

QuickSearchParameters *body = ; //  (optional)

DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.DiscoveryRESTApi()
var opts = { 
  'body':  // {{QuickSearchParameters}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.quickSearch2(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new DiscoveryRESTApi();
            var body = new QuickSearchParameters(); // QuickSearchParameters |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiDiscoveryRESTApi();
$body = ; // QuickSearchParameters | 

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

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

my $api_instance = WWW::SwaggerClient::DiscoveryRESTApi->new();
my $body = WWW::SwaggerClient::Object::QuickSearchParameters->new(); # QuickSearchParameters | 

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

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

# create an instance of the API class
api_instance = swagger_client.DiscoveryRESTApi()
body =  # QuickSearchParameters |  (optional)

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

Parameters

Body parameters

Name	Description
body

Responses

Status: 200 - On successful search

Schema

Status: 400 - Entity/attribute doesn't exist or entity filter is present without type name

relationSearch

Relationship search to search for relations(edges)

/v2/search/relations

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/search/relations?limit=&marker=&offset=&relationshipName=&sortBy=&sortOrder="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiscoveryRESTApi;

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

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 {
            AtlasSearchResult result = apiInstance.relationSearch(limit, offset, marker, relationshipName, sortBy, sortOrder);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#relationSearch");
            e.printStackTrace();
        }
    }
}

import io.swagger.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 {
            AtlasSearchResult result = apiInstance.relationSearch(limit, offset, marker, relationshipName, sortBy, sortOrder);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#relationSearch");
            e.printStackTrace();
        }
    }
}

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

DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

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. Returned data: ' + data);
  }
};
api.relationSearch(limit, offset, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new 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 marker = marker_example;  // String |  (optional) 
            var relationshipName = relationshipName_example;  // String | AtlasRelationshipType name (optional) 
            var sortBy = sortBy_example;  // String | sort the result using this attribute name, default value is 'name' (optional) 
            var sortOrder = sortOrder_example;  // String | sorting order (optional) 

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

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

$api_instance = new Swagger\Client\ApiDiscoveryRESTApi();
$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 {
    $result = $api_instance->relationSearch($limit, $offset, $marker, $relationshipName, $sortBy, $sortOrder);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DiscoveryRESTApi->relationSearch: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::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 { 
    my $result = $api_instance->relationSearch(limit => $limit, offset => $offset, marker => $marker, relationshipName => $relationshipName, sortBy => $sortBy, sortOrder => $sortOrder);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DiscoveryRESTApi->relationSearch: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.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 |  (optional)
relationshipName = relationshipName_example # String | AtlasRelationshipType name (optional)
sortBy = sortBy_example # String | sort the result using this attribute name, default value is 'name' (optional)
sortOrder = sortOrder_example # String | sorting order (optional)

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

Parameters

Query parameters

Name	Description
limit*	Integer (int32) limit the result set to only include the specified number of entries Required
marker	String
offset*	Integer (int32) start offset of the result set (useful for pagination) Required
relationshipName	String AtlasRelationshipType name
sortBy	String sort the result using this attribute name, default value is 'name'
sortOrder	String sorting order

Responses

Status: 200 - On successful search

Schema

relationSearch2

Relationship search to search for relations(edges)

/v2/search/relations

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/api/atlas//v2/search/relations"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiscoveryRESTApi;

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

public class DiscoveryRESTApiExample {

    public static void main(String[] args) {
        
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        RelationshipSearchParameters body = ; // RelationshipSearchParameters | RelationshipSearchParameters
        try {
            AtlasSearchResult result = apiInstance.relationSearch2(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#relationSearch2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DiscoveryRESTApi;

public class DiscoveryRESTApiExample {

    public static void main(String[] args) {
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        RelationshipSearchParameters body = ; // RelationshipSearchParameters | RelationshipSearchParameters
        try {
            AtlasSearchResult result = apiInstance.relationSearch2(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#relationSearch2");
            e.printStackTrace();
        }
    }
}

RelationshipSearchParameters *body = ; // RelationshipSearchParameters (optional)

DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.DiscoveryRESTApi()
var opts = { 
  'body':  // {{RelationshipSearchParameters}} RelationshipSearchParameters
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.relationSearch2(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new DiscoveryRESTApi();
            var body = new RelationshipSearchParameters(); // RelationshipSearchParameters | RelationshipSearchParameters (optional) 

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

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

$api_instance = new Swagger\Client\ApiDiscoveryRESTApi();
$body = ; // RelationshipSearchParameters | RelationshipSearchParameters

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

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

my $api_instance = WWW::SwaggerClient::DiscoveryRESTApi->new();
my $body = WWW::SwaggerClient::Object::RelationshipSearchParameters->new(); # RelationshipSearchParameters | RelationshipSearchParameters

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

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

# create an instance of the API class
api_instance = swagger_client.DiscoveryRESTApi()
body =  # RelationshipSearchParameters | RelationshipSearchParameters (optional)

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

Parameters

Body parameters

Name	Description
body

Responses

Status: 200 - On successful search

Schema

searchRelatedEntities

Relationship search to search for related entities satisfying the search parameters

/v2/search/relationship

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/search/relationship?attributes=&excludeDeletedEntities=&getApproximateCount=&guid=&includeClassificationAttributes=&limit=&offset=&relation=&sortBy=&sortOrder="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiscoveryRESTApi;

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

public class DiscoveryRESTApiExample {

    public static void main(String[] args) {
        
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        Boolean excludeDeletedEntities = true; // Boolean | 
        Boolean getApproximateCount = true; // Boolean | 
        Boolean includeClassificationAttributes = 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)
        array[String] attributes = ; // array[String] | set of attributes in search result.
        String guid = guid_example; // String | Attribute name
        String relation = relation_example; // String | relationName
        String sortBy = sortBy_example; // String | sort the result using this attribute name, default value is 'name'
        String sortOrder = sortOrder_example; // String | sorting order
        try {
            AtlasSearchResult result = apiInstance.searchRelatedEntities(excludeDeletedEntities, getApproximateCount, includeClassificationAttributes, limit, offset, attributes, guid, relation, sortBy, sortOrder);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#searchRelatedEntities");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DiscoveryRESTApi;

public class DiscoveryRESTApiExample {

    public static void main(String[] args) {
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        Boolean excludeDeletedEntities = true; // Boolean | 
        Boolean getApproximateCount = true; // Boolean | 
        Boolean includeClassificationAttributes = 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)
        array[String] attributes = ; // array[String] | set of attributes in search result.
        String guid = guid_example; // String | Attribute name
        String relation = relation_example; // String | relationName
        String sortBy = sortBy_example; // String | sort the result using this attribute name, default value is 'name'
        String sortOrder = sortOrder_example; // String | sorting order
        try {
            AtlasSearchResult result = apiInstance.searchRelatedEntities(excludeDeletedEntities, getApproximateCount, includeClassificationAttributes, limit, offset, attributes, guid, relation, sortBy, sortOrder);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#searchRelatedEntities");
            e.printStackTrace();
        }
    }
}

Boolean *excludeDeletedEntities = true; // 
Boolean *getApproximateCount = true; // 
Boolean *includeClassificationAttributes = true; // 
Integer *limit = 56; // limit the result set to only include the specified number of entries
Integer *offset = 56; // start offset of the result set (useful for pagination)
array[String] *attributes = ; // set of attributes in search result. (optional)
String *guid = guid_example; // Attribute name (optional)
String *relation = relation_example; // relationName (optional)
String *sortBy = sortBy_example; // sort the result using this attribute name, default value is 'name' (optional)
String *sortOrder = sortOrder_example; // sorting order (optional)

DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.DiscoveryRESTApi()
var excludeDeletedEntities = true; // {{Boolean}} 
var getApproximateCount = true; // {{Boolean}} 
var includeClassificationAttributes = 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 = { 
  'attributes': , // {{array[String]}} set of attributes in search result.
  'guid': guid_example, // {{String}} Attribute name
  'relation': relation_example, // {{String}} relationName
  '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. Returned data: ' + data);
  }
};
api.searchRelatedEntities(excludeDeletedEntities, getApproximateCount, includeClassificationAttributes, limit, offset, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new DiscoveryRESTApi();
            var excludeDeletedEntities = true;  // Boolean | 
            var getApproximateCount = true;  // Boolean | 
            var includeClassificationAttributes = 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 attributes = new array[String](); // array[String] | set of attributes in search result. (optional) 
            var guid = guid_example;  // String | Attribute name (optional) 
            var relation = relation_example;  // String | relationName (optional) 
            var sortBy = sortBy_example;  // String | sort the result using this attribute name, default value is 'name' (optional) 
            var sortOrder = sortOrder_example;  // String | sorting order (optional) 

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

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

$api_instance = new Swagger\Client\ApiDiscoveryRESTApi();
$excludeDeletedEntities = true; // Boolean | 
$getApproximateCount = true; // Boolean | 
$includeClassificationAttributes = 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)
$attributes = ; // array[String] | set of attributes in search result.
$guid = guid_example; // String | Attribute name
$relation = relation_example; // String | relationName
$sortBy = sortBy_example; // String | sort the result using this attribute name, default value is 'name'
$sortOrder = sortOrder_example; // String | sorting order

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

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

my $api_instance = WWW::SwaggerClient::DiscoveryRESTApi->new();
my $excludeDeletedEntities = true; # Boolean | 
my $getApproximateCount = true; # Boolean | 
my $includeClassificationAttributes = 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 $attributes = []; # array[String] | set of attributes in search result.
my $guid = guid_example; # String | Attribute name
my $relation = relation_example; # String | relationName
my $sortBy = sortBy_example; # String | sort the result using this attribute name, default value is 'name'
my $sortOrder = sortOrder_example; # String | sorting order

eval { 
    my $result = $api_instance->searchRelatedEntities(excludeDeletedEntities => $excludeDeletedEntities, getApproximateCount => $getApproximateCount, includeClassificationAttributes => $includeClassificationAttributes, limit => $limit, offset => $offset, attributes => $attributes, guid => $guid, relation => $relation, sortBy => $sortBy, sortOrder => $sortOrder);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DiscoveryRESTApi->searchRelatedEntities: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.DiscoveryRESTApi()
excludeDeletedEntities = true # Boolean | 
getApproximateCount = true # Boolean | 
includeClassificationAttributes = 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)
attributes =  # array[String] | set of attributes in search result. (optional)
guid = guid_example # String | Attribute name (optional)
relation = relation_example # String | relationName (optional)
sortBy = sortBy_example # String | sort the result using this attribute name, default value is 'name' (optional)
sortOrder = sortOrder_example # String | sorting order (optional)

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

Parameters

Query parameters

Name	Description
attributes	array[String] set of attributes in search result.
excludeDeletedEntities*	Boolean Required
getApproximateCount*	Boolean Required
guid	String Attribute name
includeClassificationAttributes*	Boolean Required
limit*	Integer (int32) limit the result set to only include the specified number of entries Required
offset*	Integer (int32) start offset of the result set (useful for pagination) Required
relation	String relationName
sortBy	String sort the result using this attribute name, default value is 'name'
sortOrder	String sorting order

Responses

Status: 200 - On successful search

Schema

Status: 400 - guid is not a valid entity type or attributeName is not a valid relationship attribute

searchUsingAttribute

Retrieve data for the specified attribute search query

/v2/search/attribute

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/search/attribute?attrName=&attrValuePrefix=&limit=&offset=&typeName="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiscoveryRESTApi;

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

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 {
            AtlasSearchResult result = apiInstance.searchUsingAttribute(limit, offset, attrName, attrValuePrefix, typeName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#searchUsingAttribute");
            e.printStackTrace();
        }
    }
}

import io.swagger.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 {
            AtlasSearchResult result = apiInstance.searchUsingAttribute(limit, offset, attrName, attrValuePrefix, typeName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#searchUsingAttribute");
            e.printStackTrace();
        }
    }
}

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

DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

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. Returned data: ' + data);
  }
};
api.searchUsingAttribute(limit, offset, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new 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 attrName = attrName_example;  // String | Attribute name (optional) 
            var attrValuePrefix = attrValuePrefix_example;  // String | Attibute value to search on (optional) 
            var typeName = typeName_example;  // String | limit the result to only entities of specified type or its sub-types (optional) 

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

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

$api_instance = new Swagger\Client\ApiDiscoveryRESTApi();
$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 {
    $result = $api_instance->searchUsingAttribute($limit, $offset, $attrName, $attrValuePrefix, $typeName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DiscoveryRESTApi->searchUsingAttribute: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::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 { 
    my $result = $api_instance->searchUsingAttribute(limit => $limit, offset => $offset, attrName => $attrName, attrValuePrefix => $attrValuePrefix, typeName => $typeName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DiscoveryRESTApi->searchUsingAttribute: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.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 (optional)
attrValuePrefix = attrValuePrefix_example # String | Attibute value to search on (optional)
typeName = typeName_example # String | limit the result to only entities of specified type or its sub-types (optional)

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

Parameters

Query parameters

Name	Description
attrName	String Attribute name
attrValuePrefix	String Attibute value to search on
limit*	Integer (int32) limit the result set to only include the specified number of entries Required
offset*	Integer (int32) start offset of the result set (useful for pagination) Required
typeName	String limit the result to only entities of specified type or its sub-types

Responses

Status: 200 - On successful FullText lookup with some results, might return an empty list if execution succeeded without any results

Schema

Status: 400 - Invalid wildcard or query parameters

searchUsingBasic

Retrieve data for the specified fulltext query

/v2/search/basic

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/search/basic?classification=&excludeDeletedEntities=&limit=&marker=&offset=&query=&sortBy=&sortOrder=&typeName="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiscoveryRESTApi;

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

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 {
            AtlasSearchResult result = apiInstance.searchUsingBasic(excludeDeletedEntities, limit, offset, classification, marker, query, sortBy, sortOrder, typeName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#searchUsingBasic");
            e.printStackTrace();
        }
    }
}

import io.swagger.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 {
            AtlasSearchResult result = apiInstance.searchUsingBasic(excludeDeletedEntities, limit, offset, classification, marker, query, sortBy, sortOrder, typeName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#searchUsingBasic");
            e.printStackTrace();
        }
    }
}

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

DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

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. Returned data: ' + data);
  }
};
api.searchUsingBasic(excludeDeletedEntities, limit, offset, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new 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 classification = classification_example;  // String | limit the result to only entities tagged with the given classification or or its sub-types (optional) 
            var marker = marker_example;  // String |  (optional) 
            var query = query_example;  // String | Fulltext query (optional) 
            var sortBy = sortBy_example;  // String |  (optional) 
            var sortOrder = sortOrder_example;  // String |  (optional) 
            var typeName = typeName_example;  // String | limit the result to only entities of specified type or its sub-types (optional) 

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

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

$api_instance = new Swagger\Client\ApiDiscoveryRESTApi();
$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 {
    $result = $api_instance->searchUsingBasic($excludeDeletedEntities, $limit, $offset, $classification, $marker, $query, $sortBy, $sortOrder, $typeName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DiscoveryRESTApi->searchUsingBasic: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::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 { 
    my $result = $api_instance->searchUsingBasic(excludeDeletedEntities => $excludeDeletedEntities, limit => $limit, offset => $offset, classification => $classification, marker => $marker, query => $query, sortBy => $sortBy, sortOrder => $sortOrder, typeName => $typeName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DiscoveryRESTApi->searchUsingBasic: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.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 (optional)
marker = marker_example # String |  (optional)
query = query_example # String | Fulltext query (optional)
sortBy = sortBy_example # String |  (optional)
sortOrder = sortOrder_example # String |  (optional)
typeName = typeName_example # String | limit the result to only entities of specified type or its sub-types (optional)

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

Parameters

Query parameters

Name	Description
classification	String limit the result to only entities tagged with the given classification or or its sub-types
excludeDeletedEntities*	Boolean Required
limit*	Integer (int32) limit the result set to only include the specified number of entries Required
marker	String
offset*	Integer (int32) start offset of the result set (useful for pagination) Required
query	String Fulltext query
sortBy	String
sortOrder	String
typeName	String limit the result to only entities of specified type or its sub-types

Responses

Status: 200 - On successful FullText lookup with some results, might return an empty list if execution succeeded without any results

Schema

Status: 400 - Invalid fulltext or query parameters

searchUsingDSL

Retrieve data for the specified DSL

/v2/search/dsl

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/search/dsl?classification=&limit=&offset=&query=&typeName="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiscoveryRESTApi;

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

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 {
            AtlasSearchResult result = apiInstance.searchUsingDSL(limit, offset, classification, query, typeName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#searchUsingDSL");
            e.printStackTrace();
        }
    }
}

import io.swagger.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 {
            AtlasSearchResult result = apiInstance.searchUsingDSL(limit, offset, classification, query, typeName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#searchUsingDSL");
            e.printStackTrace();
        }
    }
}

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

DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

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. Returned data: ' + data);
  }
};
api.searchUsingDSL(limit, offset, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new 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 classification = classification_example;  // String | limit the result to only entities tagged with the given classification or or its sub-types (optional) 
            var query = query_example;  // String | DSL query (optional) 
            var typeName = typeName_example;  // String | limit the result to only entities of specified type or its sub-types (optional) 

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

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

$api_instance = new Swagger\Client\ApiDiscoveryRESTApi();
$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 {
    $result = $api_instance->searchUsingDSL($limit, $offset, $classification, $query, $typeName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DiscoveryRESTApi->searchUsingDSL: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::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 { 
    my $result = $api_instance->searchUsingDSL(limit => $limit, offset => $offset, classification => $classification, query => $query, typeName => $typeName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DiscoveryRESTApi->searchUsingDSL: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.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 (optional)
query = query_example # String | DSL query (optional)
typeName = typeName_example # String | limit the result to only entities of specified type or its sub-types (optional)

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

Parameters

Query parameters

Name	Description
classification	String limit the result to only entities tagged with the given classification or or its sub-types
limit*	Integer (int32) limit the result set to only include the specified number of entries Required
offset*	Integer (int32) start offset of the result set (useful for pagination) Required
query	String DSL query
typeName	String limit the result to only entities of specified type or its sub-types

Responses

Status: 200 - On successful DSL execution with some results, might return an empty list if execution succeeded without any results

Schema

Status: 400 - Invalid DSL or query parameters

searchUsingFullText

Retrieve data for the specified fulltext query

/v2/search/fulltext

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/search/fulltext?excludeDeletedEntities=&limit=&offset=&query="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiscoveryRESTApi;

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

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 {
            AtlasSearchResult result = apiInstance.searchUsingFullText(excludeDeletedEntities, limit, offset, query);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#searchUsingFullText");
            e.printStackTrace();
        }
    }
}

import io.swagger.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 {
            AtlasSearchResult result = apiInstance.searchUsingFullText(excludeDeletedEntities, limit, offset, query);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#searchUsingFullText");
            e.printStackTrace();
        }
    }
}

Boolean *excludeDeletedEntities = true; // 
Integer *limit = 56; // limit the result set to only include the specified number of entries
Integer *offset = 56; // start offset of the result set (useful for pagination)
String *query = query_example; // Fulltext query (optional)

DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

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. Returned data: ' + data);
  }
};
api.searchUsingFullText(excludeDeletedEntities, limit, offset, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new 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 query = query_example;  // String | Fulltext query (optional) 

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

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

$api_instance = new Swagger\Client\ApiDiscoveryRESTApi();
$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 {
    $result = $api_instance->searchUsingFullText($excludeDeletedEntities, $limit, $offset, $query);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DiscoveryRESTApi->searchUsingFullText: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::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 { 
    my $result = $api_instance->searchUsingFullText(excludeDeletedEntities => $excludeDeletedEntities, limit => $limit, offset => $offset, query => $query);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DiscoveryRESTApi->searchUsingFullText: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.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 (optional)

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

Parameters

Query parameters

Name	Description
excludeDeletedEntities*	Boolean Required
limit*	Integer (int32) limit the result set to only include the specified number of entries Required
offset*	Integer (int32) start offset of the result set (useful for pagination) Required
query	String Fulltext query

Responses

Status: 200 - On successful FullText lookup with some results, might return an empty list if execution succeeded without any results

Schema

Status: 400 - Invalid fulltext or query parameters

searchWithParameters

Attribute based search for entities satisfying the search parameters

/v2/search/basic

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/api/atlas//v2/search/basic"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiscoveryRESTApi;

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

public class DiscoveryRESTApiExample {

    public static void main(String[] args) {
        
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        SearchParameters body = ; // SearchParameters | Search parameters
        try {
            AtlasSearchResult result = apiInstance.searchWithParameters(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#searchWithParameters");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DiscoveryRESTApi;

public class DiscoveryRESTApiExample {

    public static void main(String[] args) {
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        SearchParameters body = ; // SearchParameters | Search parameters
        try {
            AtlasSearchResult result = apiInstance.searchWithParameters(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#searchWithParameters");
            e.printStackTrace();
        }
    }
}

SearchParameters *body = ; // Search parameters (optional)

DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.DiscoveryRESTApi()
var opts = { 
  'body':  // {{SearchParameters}} Search parameters
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.searchWithParameters(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new DiscoveryRESTApi();
            var body = new SearchParameters(); // SearchParameters | Search parameters (optional) 

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

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

$api_instance = new Swagger\Client\ApiDiscoveryRESTApi();
$body = ; // SearchParameters | Search parameters

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

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

my $api_instance = WWW::SwaggerClient::DiscoveryRESTApi->new();
my $body = WWW::SwaggerClient::Object::SearchParameters->new(); # SearchParameters | Search parameters

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

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

# create an instance of the API class
api_instance = swagger_client.DiscoveryRESTApi()
body =  # SearchParameters | Search parameters (optional)

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

Parameters

Body parameters

Name	Description
body

Responses

Status: 200 - On successful search

Schema

Status: 400 - Tag/Entity doesn't exist or Tag/entity filter is present without tag/type name

updateSavedSearch

/v2/search/saved

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/api/atlas//v2/search/saved"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiscoveryRESTApi;

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

public class DiscoveryRESTApiExample {

    public static void main(String[] args) {
        
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        AtlasUserSavedSearch body = ; // AtlasUserSavedSearch | 
        try {
            AtlasUserSavedSearch result = apiInstance.updateSavedSearch(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#updateSavedSearch");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DiscoveryRESTApi;

public class DiscoveryRESTApiExample {

    public static void main(String[] args) {
        DiscoveryRESTApi apiInstance = new DiscoveryRESTApi();
        AtlasUserSavedSearch body = ; // AtlasUserSavedSearch | 
        try {
            AtlasUserSavedSearch result = apiInstance.updateSavedSearch(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiscoveryRESTApi#updateSavedSearch");
            e.printStackTrace();
        }
    }
}

AtlasUserSavedSearch *body = ; //  (optional)

DiscoveryRESTApi *apiInstance = [[DiscoveryRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.DiscoveryRESTApi()
var opts = { 
  'body':  // {{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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new DiscoveryRESTApi();
            var body = new AtlasUserSavedSearch(); // AtlasUserSavedSearch |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiDiscoveryRESTApi();
$body = ; // AtlasUserSavedSearch | 

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

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

my $api_instance = WWW::SwaggerClient::DiscoveryRESTApi->new();
my $body = WWW::SwaggerClient::Object::AtlasUserSavedSearch->new(); # AtlasUserSavedSearch | 

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

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

# create an instance of the API class
api_instance = swagger_client.DiscoveryRESTApi()
body =  # AtlasUserSavedSearch |  (optional)

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

Parameters

Body parameters

Name	Description
body

Responses

Status: 204 - the updated search-object

Schema

EntityREST

addClassification

Bulk API to associate a tag to multiple entities. Option 1: List of GUIDs to associate a tag Option 2: Typename and list of uniq attributes for entities to associate a tag Option 3: List of GUIDs and Typename with list of uniq attributes for entities to associate a tag

/v2/entity/bulk/classification

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json"\
"/api/atlas//v2/entity/bulk/classification"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

public class EntityRESTApiExample {

    public static void main(String[] args) {
        
        EntityRESTApi apiInstance = new EntityRESTApi();
        ClassificationAssociateRequest body = ; // ClassificationAssociateRequest | 
        try {
            apiInstance.addClassification(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#addClassification");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EntityRESTApi;

public class EntityRESTApiExample {

    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        ClassificationAssociateRequest body = ; // ClassificationAssociateRequest | 
        try {
            apiInstance.addClassification(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#addClassification");
            e.printStackTrace();
        }
    }
}

ClassificationAssociateRequest *body = ; //  (optional)

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.EntityRESTApi()
var opts = { 
  'body':  // {{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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var body = new ClassificationAssociateRequest(); // ClassificationAssociateRequest |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$body = ; // ClassificationAssociateRequest | 

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

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

my $api_instance = WWW::SwaggerClient::EntityRESTApi->new();
my $body = WWW::SwaggerClient::Object::ClassificationAssociateRequest->new(); # ClassificationAssociateRequest | 

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

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

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
body =  # ClassificationAssociateRequest |  (optional)

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

Parameters

Body parameters

Name	Description
body

Responses

Status: 201 - Success

addClassifications

Adds classifications to an existing entity represented by a guid.

/v2/entity/guid/{guid}/classifications

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json"\
"/api/atlas//v2/entity/guid/{guid}/classifications"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

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] body = ; // array[AtlasClassification] | 
        try {
            apiInstance.addClassifications(guid, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#addClassifications");
            e.printStackTrace();
        }
    }
}

import io.swagger.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] body = ; // array[AtlasClassification] | 
        try {
            apiInstance.addClassifications(guid, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#addClassifications");
            e.printStackTrace();
        }
    }
}

String *guid = guid_example; // globally unique identifier for the entity
array[AtlasClassification] *body = ; //  (optional)

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.EntityRESTApi()
var guid = guid_example; // {{String}} globally unique identifier for the entity
var opts = { 
  'body':  // {{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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var guid = guid_example;  // String | globally unique identifier for the entity
            var body = new array[AtlasClassification](); // array[AtlasClassification] |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$guid = guid_example; // String | globally unique identifier for the entity
$body = ; // array[AtlasClassification] | 

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

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

my $api_instance = WWW::SwaggerClient::EntityRESTApi->new();
my $guid = guid_example; # String | globally unique identifier for the entity
my $body = [WWW::SwaggerClient::Object::array[AtlasClassification]->new()]; # array[AtlasClassification] | 

eval { 
    $api_instance->addClassifications(guid => $guid, body => $body);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->addClassifications: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
guid = guid_example # String | globally unique identifier for the entity
body =  # array[AtlasClassification] |  (optional)

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

Parameters

Path parameters

Name	Description
guid*	String globally unique identifier for the entity Required

Body parameters

Name	Description
body

Responses

Status: 201 - Success

addClassificationsByUniqueAttribute

Adds classification to the entity identified by its type and unique attributes.

/v2/entity/uniqueAttribute/type/{typeName}/classifications

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json"\
"/api/atlas//v2/entity/uniqueAttribute/type/{typeName}/classifications"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

public class EntityRESTApiExample {

    public static void main(String[] args) {
        
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | 
        array[AtlasClassification] body = ; // array[AtlasClassification] | 
        try {
            apiInstance.addClassificationsByUniqueAttribute(typeName, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#addClassificationsByUniqueAttribute");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EntityRESTApi;

public class EntityRESTApiExample {

    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | 
        array[AtlasClassification] body = ; // array[AtlasClassification] | 
        try {
            apiInstance.addClassificationsByUniqueAttribute(typeName, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#addClassificationsByUniqueAttribute");
            e.printStackTrace();
        }
    }
}

String *typeName = typeName_example; // 
array[AtlasClassification] *body = ; //  (optional)

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.EntityRESTApi()
var typeName = typeName_example; // {{String}} 
var opts = { 
  'body':  // {{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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var typeName = typeName_example;  // String | 
            var body = new array[AtlasClassification](); // array[AtlasClassification] |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$typeName = typeName_example; // String | 
$body = ; // array[AtlasClassification] | 

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

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

my $api_instance = WWW::SwaggerClient::EntityRESTApi->new();
my $typeName = typeName_example; # String | 
my $body = [WWW::SwaggerClient::Object::array[AtlasClassification]->new()]; # array[AtlasClassification] | 

eval { 
    $api_instance->addClassificationsByUniqueAttribute(typeName => $typeName, body => $body);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->addClassificationsByUniqueAttribute: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
typeName = typeName_example # String | 
body =  # array[AtlasClassification] |  (optional)

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

Parameters

Path parameters

Name	Description
typeName*	String Required

Body parameters

Name	Description
body

Responses

Status: 201 - Success

addLabels

add given labels to a given entity

/v2/entity/guid/{guid}/labels

Usage and SDK Samples

curl -X PUT\
-H "Content-Type: application/json"\
"/api/atlas//v2/entity/guid/{guid}/labels"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

public class EntityRESTApiExample {

    public static void main(String[] args) {
        
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | - Unique entity identifier
        array[String] body = ; // array[String] | 
        try {
            apiInstance.addLabels(guid, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#addLabels");
            e.printStackTrace();
        }
    }
}

import io.swagger.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] body = ; // array[String] | 
        try {
            apiInstance.addLabels(guid, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#addLabels");
            e.printStackTrace();
        }
    }
}

String *guid = guid_example; // - Unique entity identifier
array[String] *body = ; //  (optional)

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.EntityRESTApi()
var guid = guid_example; // {{String}} - Unique entity identifier
var opts = { 
  'body':  // {{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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var guid = guid_example;  // String | - Unique entity identifier
            var body = new array[String](); // array[String] |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$guid = guid_example; // String | - Unique entity identifier
$body = ; // array[String] | 

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

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

my $api_instance = WWW::SwaggerClient::EntityRESTApi->new();
my $guid = guid_example; # String | - Unique entity identifier
my $body = [WWW::SwaggerClient::Object::array[String]->new()]; # array[String] | 

eval { 
    $api_instance->addLabels(guid => $guid, body => $body);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->addLabels: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
guid = guid_example # String | - Unique entity identifier
body =  # array[String] |  (optional)

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

Parameters

Path parameters

Name	Description
guid*	String - Unique entity identifier Required

Body parameters

Name	Description
body

Responses

Status: 204 - Success

addLabels_1

/v2/entity/uniqueAttribute/type/{typeName}/labels

Usage and SDK Samples

curl -X PUT\
-H "Content-Type: application/json"\
"/api/atlas//v2/entity/uniqueAttribute/type/{typeName}/labels"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

public class EntityRESTApiExample {

    public static void main(String[] args) {
        
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | 
        array[String] body = ; // array[String] | 
        try {
            apiInstance.addLabels_0(typeName, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#addLabels_0");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EntityRESTApi;

public class EntityRESTApiExample {

    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | 
        array[String] body = ; // array[String] | 
        try {
            apiInstance.addLabels_0(typeName, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#addLabels_0");
            e.printStackTrace();
        }
    }
}

String *typeName = typeName_example; // 
array[String] *body = ; //  (optional)

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.EntityRESTApi()
var typeName = typeName_example; // {{String}} 
var opts = { 
  'body':  // {{array[String]}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.addLabels_0(typeName, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var typeName = typeName_example;  // String | 
            var body = new array[String](); // array[String] |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$typeName = typeName_example; // String | 
$body = ; // array[String] | 

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

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

my $api_instance = WWW::SwaggerClient::EntityRESTApi->new();
my $typeName = typeName_example; # String | 
my $body = [WWW::SwaggerClient::Object::array[String]->new()]; # array[String] | 

eval { 
    $api_instance->addLabels_0(typeName => $typeName, body => $body);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->addLabels_0: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
typeName = typeName_example # String | 
body =  # array[String] |  (optional)

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

Parameters

Path parameters

Name	Description
typeName*	String Required

Body parameters

Name	Description
body

Responses

Status: 204 - Success

addOrUpdateBusinessAttributes

/v2/entity/guid/{guid}/businessmetadata

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json"\
"/api/atlas//v2/entity/guid/{guid}/businessmetadata?isOverwrite="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

public class EntityRESTApiExample {

    public static void main(String[] args) {
        
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | 
        map[String, Object] body = ; // map[String, Object] | 
        Boolean isOverwrite = true; // Boolean | 
        try {
            apiInstance.addOrUpdateBusinessAttributes(guid, body, isOverwrite);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#addOrUpdateBusinessAttributes");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EntityRESTApi;

public class EntityRESTApiExample {

    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | 
        map[String, Object] body = ; // map[String, Object] | 
        Boolean isOverwrite = true; // Boolean | 
        try {
            apiInstance.addOrUpdateBusinessAttributes(guid, body, isOverwrite);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#addOrUpdateBusinessAttributes");
            e.printStackTrace();
        }
    }
}

String *guid = guid_example; // 
map[String, Object] *body = ; //  (optional)
Boolean *isOverwrite = true; //  (optional) (default to false)

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.EntityRESTApi()
var guid = guid_example; // {{String}} 
var opts = { 
  'body':  // {{map[String, Object]}} 
  'isOverwrite': true // {{Boolean}} 
};
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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var guid = guid_example;  // String | 
            var body = new map[String, Object](); // map[String, Object] |  (optional) 
            var isOverwrite = true;  // Boolean |  (optional)  (default to false)

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

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

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$guid = guid_example; // String | 
$body = ; // map[String, Object] | 
$isOverwrite = true; // Boolean | 

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

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

my $api_instance = WWW::SwaggerClient::EntityRESTApi->new();
my $guid = guid_example; # String | 
my $body = WWW::SwaggerClient::Object::map[String, Object]->new(); # map[String, Object] | 
my $isOverwrite = true; # Boolean | 

eval { 
    $api_instance->addOrUpdateBusinessAttributes(guid => $guid, body => $body, isOverwrite => $isOverwrite);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->addOrUpdateBusinessAttributes: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
guid = guid_example # String | 
body =  # map[String, Object] |  (optional)
isOverwrite = true # Boolean |  (optional) (default to false)

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

Parameters

Path parameters

Name	Description
guid*	String Required

Body parameters

Name	Description
body

Query parameters

Name	Description
isOverwrite	Boolean

Responses

Status: 201 - Success

addOrUpdateBusinessAttributes_2

/v2/entity/guid/{guid}/businessmetadata/{bmName}

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json"\
"/api/atlas//v2/entity/guid/{guid}/businessmetadata/{bmName}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

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] body = ; // map[String, Object] | 
        try {
            apiInstance.addOrUpdateBusinessAttributes_0(bmName, guid, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#addOrUpdateBusinessAttributes_0");
            e.printStackTrace();
        }
    }
}

import io.swagger.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] body = ; // map[String, Object] | 
        try {
            apiInstance.addOrUpdateBusinessAttributes_0(bmName, guid, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#addOrUpdateBusinessAttributes_0");
            e.printStackTrace();
        }
    }
}

String *bmName = bmName_example; // 
String *guid = guid_example; // 
map[String, Object] *body = ; //  (optional)

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.EntityRESTApi()
var bmName = bmName_example; // {{String}} 
var guid = guid_example; // {{String}} 
var opts = { 
  'body':  // {{map[String, Object]}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.addOrUpdateBusinessAttributes_0(bmNameguid, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var bmName = bmName_example;  // String | 
            var guid = guid_example;  // String | 
            var body = new map[String, Object](); // map[String, Object] |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$bmName = bmName_example; // String | 
$guid = guid_example; // String | 
$body = ; // map[String, Object] | 

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

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

my $api_instance = WWW::SwaggerClient::EntityRESTApi->new();
my $bmName = bmName_example; # String | 
my $guid = guid_example; # String | 
my $body = WWW::SwaggerClient::Object::map[String, Object]->new(); # map[String, Object] | 

eval { 
    $api_instance->addOrUpdateBusinessAttributes_0(bmName => $bmName, guid => $guid, body => $body);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->addOrUpdateBusinessAttributes_0: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
bmName = bmName_example # String | 
guid = guid_example # String | 
body =  # map[String, Object] |  (optional)

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

Parameters

Path parameters

Name	Description
bmName*	String Required
guid*	String Required

Body parameters

Name	Description
body

Responses

Status: 201 - Success

createOrUpdate

Create new entity or update existing entity in Atlas. Existing entity is matched using its unique guid if supplied or by its unique attributes eg: qualifiedName

/v2/entity

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/api/atlas//v2/entity"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

public class EntityRESTApiExample {

    public static void main(String[] args) {
        
        EntityRESTApi apiInstance = new EntityRESTApi();
        AtlasEntityWithExtInfo body = ; // AtlasEntityWithExtInfo | 
        try {
            EntityMutationResponse result = apiInstance.createOrUpdate(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#createOrUpdate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EntityRESTApi;

public class EntityRESTApiExample {

    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        AtlasEntityWithExtInfo body = ; // AtlasEntityWithExtInfo | 
        try {
            EntityMutationResponse result = apiInstance.createOrUpdate(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#createOrUpdate");
            e.printStackTrace();
        }
    }
}

AtlasEntityWithExtInfo *body = ; //  (optional)

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.EntityRESTApi()
var opts = { 
  'body':  // {{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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var body = new AtlasEntityWithExtInfo(); // AtlasEntityWithExtInfo |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$body = ; // AtlasEntityWithExtInfo | 

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

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

my $api_instance = WWW::SwaggerClient::EntityRESTApi->new();
my $body = WWW::SwaggerClient::Object::AtlasEntityWithExtInfo->new(); # AtlasEntityWithExtInfo | 

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

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

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
body =  # AtlasEntityWithExtInfo |  (optional)

try: 
    api_response = api_instance.create_or_update(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EntityRESTApi->createOrUpdate: %s\n" % e)

Parameters

Body parameters

Name	Description
body

Responses

Status: 201 - EntityMutationResponse

Schema

createOrUpdate_3

Bulk API to create new entities or updates existing entities in Atlas. Existing entity is matched using its unique guid if supplied or by its unique attributes eg: qualifiedName

/v2/entity/bulk

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/api/atlas//v2/entity/bulk"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

public class EntityRESTApiExample {

    public static void main(String[] args) {
        
        EntityRESTApi apiInstance = new EntityRESTApi();
        AtlasEntitiesWithExtInfo body = ; // AtlasEntitiesWithExtInfo | 
        try {
            EntityMutationResponse result = apiInstance.createOrUpdate_0(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#createOrUpdate_0");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EntityRESTApi;

public class EntityRESTApiExample {

    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        AtlasEntitiesWithExtInfo body = ; // AtlasEntitiesWithExtInfo | 
        try {
            EntityMutationResponse result = apiInstance.createOrUpdate_0(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#createOrUpdate_0");
            e.printStackTrace();
        }
    }
}

AtlasEntitiesWithExtInfo *body = ; //  (optional)

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.EntityRESTApi()
var opts = { 
  'body':  // {{AtlasEntitiesWithExtInfo}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createOrUpdate_0(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var body = new AtlasEntitiesWithExtInfo(); // AtlasEntitiesWithExtInfo |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$body = ; // AtlasEntitiesWithExtInfo | 

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

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

my $api_instance = WWW::SwaggerClient::EntityRESTApi->new();
my $body = WWW::SwaggerClient::Object::AtlasEntitiesWithExtInfo->new(); # AtlasEntitiesWithExtInfo | 

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

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

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
body =  # AtlasEntitiesWithExtInfo |  (optional)

try: 
    api_response = api_instance.create_or_update_0(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EntityRESTApi->createOrUpdate_0: %s\n" % e)

Parameters

Body parameters

Name	Description
body

Responses

Status: 201 -

Schema

deleteByGuid

Delete an entity identified by its GUID.

/v2/entity/guid/{guid}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"/api/atlas//v2/entity/guid/{guid}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

String *guid = guid_example; // GUID for the entity

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var guid = guid_example;  // String | GUID for the entity

            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');

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::EntityRESTApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
guid = guid_example # String | GUID for the entity

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)

Parameters

Path parameters

Name	Description
guid*	String GUID for the entity Required

Responses

Status: 204 - EntityMutationResponse

Schema

deleteByGuids

Bulk API to delete list of entities identified by its GUIDs

/v2/entity/bulk

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"/api/atlas//v2/entity/bulk?guid="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

array[String] *guid = ; //  (optional)

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var guid = new array[String](); // array[String] |  (optional) 

            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');

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::EntityRESTApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
guid =  # array[String] |  (optional)

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)

Parameters

Query parameters

Name	Description
guid	array[String]

Responses

Status: 204 -

Schema

deleteByUniqueAttribute

Delete an entity identified by its type and unique attributes. In addition to the typeName path parameter, attribute key-value pair(s) can be provided in the following format attr:<attrName>=<attrValue> NOTE: The attrName and attrValue should be unique across entities, eg. qualifiedName The REST request would look something like this DELETE /v2/entity/uniqueAttribute/type/aType?attr:aTypeAttribute=someValue

/v2/entity/uniqueAttribute/type/{typeName}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"/api/atlas//v2/entity/uniqueAttribute/type/{typeName}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

String *typeName = typeName_example; // - entity type to be deleted

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var typeName = typeName_example;  // String | - entity type to be deleted

            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');

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::EntityRESTApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
typeName = typeName_example # String | - entity type to be deleted

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)

Parameters

Path parameters

Name	Description
typeName*	String - entity type to be deleted Required

Responses

Status: 204 - EntityMutationResponse

Schema

deleteClassification

Deletes a given classification from an existing entity represented by a guid.

/v2/entity/guid/{guid}/classification/{classificationName}

Usage and SDK Samples

curl -X DELETE\
"/api/atlas//v2/entity/guid/{guid}/classification/{classificationName}?associatedEntityGuid="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

String *classificationName = classificationName_example; // name of the classifcation
String *guid = guid_example; // globally unique identifier for the entity
String *associatedEntityGuid = associatedEntityGuid_example; //  (optional)

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var classificationName = classificationName_example;  // String | name of the classifcation
            var guid = guid_example;  // String | globally unique identifier for the entity
            var associatedEntityGuid = associatedEntityGuid_example;  // String |  (optional) 

            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');

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::EntityRESTApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
classificationName = classificationName_example # String | name of the classifcation
guid = guid_example # String | globally unique identifier for the entity
associatedEntityGuid = associatedEntityGuid_example # String |  (optional)

try: 
    api_instance.delete_classification(classificationName, guid, associatedEntityGuid=associatedEntityGuid)
except ApiException as e:
    print("Exception when calling EntityRESTApi->deleteClassification: %s\n" % e)

Parameters

Path parameters

Name	Description
classificationName*	String name of the classifcation Required
guid*	String globally unique identifier for the entity Required

Query parameters

Name	Description
associatedEntityGuid	String

Responses

Status: 204 - Success

deleteClassificationByUniqueAttribute

Deletes a given classification from an entity identified by its type and unique attributes.

/v2/entity/uniqueAttribute/type/{typeName}/classification/{classificationName}

Usage and SDK Samples

curl -X DELETE\
"/api/atlas//v2/entity/uniqueAttribute/type/{typeName}/classification/{classificationName}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

String *classificationName = classificationName_example; // name of the classification
String *typeName = typeName_example; // 

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var classificationName = classificationName_example;  // String | name of the classification
            var typeName = typeName_example;  // String | 

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

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

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::EntityRESTApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
classificationName = classificationName_example # String | name of the classification
typeName = typeName_example # String | 

try: 
    api_instance.delete_classification_by_unique_attribute(classificationName, typeName)
except ApiException as e:
    print("Exception when calling EntityRESTApi->deleteClassificationByUniqueAttribute: %s\n" % e)

Parameters

Path parameters

Name	Description
classificationName*	String name of the classification Required
typeName*	String Required

Responses

Status: 204 - Success

getAuditEvents

/v2/entity/{guid}/audit

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/entity/{guid}/audit?auditAction=&count=&offset=&sortBy=&sortOrder=&startKey="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

String *guid = guid_example; // 
String *auditAction = auditAction_example; //  (optional)
Integer *count = 56; //  (optional) (default to 100)
Integer *offset = 56; //  (optional) (default to -1)
String *sortBy = sortBy_example; //  (optional)
String *sortOrder = sortOrder_example; //  (optional)
String *startKey = startKey_example; //  (optional)

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

[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');

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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var guid = guid_example;  // String | 
            var auditAction = auditAction_example;  // String |  (optional) 
            var count = 56;  // Integer |  (optional)  (default to 100)
            var offset = 56;  // Integer |  (optional)  (default to -1)
            var sortBy = sortBy_example;  // String |  (optional) 
            var sortOrder = sortOrder_example;  // String |  (optional) 
            var startKey = startKey_example;  // String |  (optional) 

            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');

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::EntityRESTApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
guid = guid_example # String | 
auditAction = auditAction_example # String |  (optional)
count = 56 # Integer |  (optional) (default to 100)
offset = 56 # Integer |  (optional) (default to -1)
sortBy = sortBy_example # String |  (optional)
sortOrder = sortOrder_example # String |  (optional)
startKey = startKey_example # String |  (optional)

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)

Parameters

Path parameters

Name	Description
guid*	String Required

Query parameters

Name	Description
auditAction	String
count	Integer (int32)
offset	Integer (int32)
sortBy	String
sortOrder	String
startKey	String

Responses

Status: 200 -

Schema

getByGuids

Bulk API to retrieve list of entities identified by its GUIDs.

/v2/entity/bulk

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/entity/bulk?guid=&ignoreRelationships=&minExtInfo="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

array[String] *guid = ; //  (optional)
Boolean *ignoreRelationships = true; //  (optional) (default to false)
Boolean *minExtInfo = true; //  (optional) (default to false)

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

[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');

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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var guid = new array[String](); // array[String] |  (optional) 
            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');

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::EntityRESTApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
guid =  # array[String] |  (optional)
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)

Parameters

Query parameters

Name	Description
guid	array[String]
ignoreRelationships	Boolean
minExtInfo	Boolean

Responses

Status: 200 -

Schema

getById

Fetch complete definition of an entity given its GUID.

/v2/entity/guid/{guid}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/entity/guid/{guid}?ignoreRelationships=&minExtInfo="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

String *guid = guid_example; // GUID for the entity
Boolean *ignoreRelationships = true; //  (optional) (default to false)
Boolean *minExtInfo = true; //  (optional) (default to false)

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

[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');

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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var guid = guid_example;  // String | GUID for the entity
            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');

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::EntityRESTApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
guid = guid_example # String | GUID for the entity
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)

Parameters

Path parameters

Name	Description
guid*	String GUID for the entity Required

Query parameters

Name	Description
ignoreRelationships	Boolean
minExtInfo	Boolean

Responses

Status: 200 - AtlasEntity

Schema

getByUniqueAttributes

Fetch complete definition of an entity given its type and unique attribute. In addition to the typeName path parameter, attribute key-value pair(s) can be provided in the following format attr:<attrName>=<attrValue> NOTE: The attrName and attrValue should be unique across entities, eg. qualifiedName The REST request would look something like this GET /v2/entity/uniqueAttribute/type/aType?attr:aTypeAttribute=someValue

/v2/entity/uniqueAttribute/type/{typeName}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/entity/uniqueAttribute/type/{typeName}?ignoreRelationships=&minExtInfo="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

String *typeName = typeName_example; // 
Boolean *ignoreRelationships = true; //  (optional) (default to false)
Boolean *minExtInfo = true; //  (optional) (default to false)

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

[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');

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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var typeName = typeName_example;  // String | 
            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');

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::EntityRESTApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
typeName = typeName_example # String | 
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)

Parameters

Path parameters

Name	Description
typeName*	String Required

Query parameters

Name	Description
ignoreRelationships	Boolean
minExtInfo	Boolean

Responses

Status: 200 - AtlasEntityWithExtInfo

Schema

getClassification

Gets the list of classifications for a given entity represented by a guid.

/v2/entity/guid/{guid}/classification/{classificationName}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/entity/guid/{guid}/classification/{classificationName}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

String *classificationName = classificationName_example; // 
String *guid = guid_example; // globally unique identifier for the entity

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

[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');

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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var classificationName = classificationName_example;  // String | 
            var guid = guid_example;  // String | globally unique identifier for the entity

            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');

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::EntityRESTApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
classificationName = classificationName_example # String | 
guid = guid_example # String | globally unique identifier for the entity

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)

Parameters

Path parameters

Name	Description
classificationName*	String Required
guid*	String globally unique identifier for the entity Required

Responses

Status: 200 - classification for the given entity guid

Schema

getClassifications

Gets the list of classifications for a given entity represented by a guid.

/v2/entity/guid/{guid}/classifications

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/entity/guid/{guid}/classifications"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

String *guid = guid_example; // globally unique identifier for the entity

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var guid = guid_example;  // String | globally unique identifier for the entity

            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');

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::EntityRESTApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
guid = guid_example # String | globally unique identifier for the entity

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

Parameters

Path parameters

Name	Description
guid*	String globally unique identifier for the entity Required

Responses

Status: 200 - a list of classifications for the given entity guid

Schema

getEntitiesByUniqueAttributes

Bulk API to retrieve list of entities identified by its unique attributes. In addition to the typeName path parameter, attribute key-value pair(s) can be provided in the following format typeName=<typeName>&attr_1:<attrName>=<attrValue>&attr_2:<attrName>=<attrValue>&attr_3:<attrName>=<attrValue> NOTE: The attrName should be an unique attribute for the given entity-type The REST request would look something like this GET /v2/entity/bulk/uniqueAttribute/type/hive_db?attr_0:qualifiedName=db1@cl1&attr_2:qualifiedName=db2@cl1

/v2/entity/bulk/uniqueAttribute/type/{typeName}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/entity/bulk/uniqueAttribute/type/{typeName}?ignoreRelationships=&minExtInfo="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

String *typeName = typeName_example; // 
Boolean *ignoreRelationships = true; //  (optional) (default to false)
Boolean *minExtInfo = true; //  (optional) (default to false)

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

[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');

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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var typeName = typeName_example;  // String | 
            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');

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::EntityRESTApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
typeName = typeName_example # String | 
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)

Parameters

Path parameters

Name	Description
typeName*	String Required

Query parameters

Name	Description
ignoreRelationships	Boolean
minExtInfo	Boolean

Responses

Status: 200 - AtlasEntitiesWithExtInfo

Schema

getEntityHeaderByUniqueAttributes

Fetch AtlasEntityHeader given its type and unique attribute. In addition to the typeName path parameter, attribute key-value pair(s) can be provided in the following format attr:<attrName>=<attrValue> NOTE: The attrName and attrValue should be unique across entities, eg. qualifiedName The REST request would look something like this GET /v2/entity/uniqueAttribute/type/aType/header?attr:aTypeAttribute=someValue

/v2/entity/uniqueAttribute/type/{typeName}/header

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/entity/uniqueAttribute/type/{typeName}/header"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

String *typeName = typeName_example; // 

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var typeName = typeName_example;  // String | 

            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');

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::EntityRESTApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
typeName = typeName_example # String | 

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)

Parameters

Path parameters

Name	Description
typeName*	String Required

Responses

Status: 200 - AtlasEntityHeader

Schema

getEntityHeaders

/v2/entity/bulk/headers

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/entity/bulk/headers?tagUpdateStartTime="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

Long *tagUpdateStartTime = 789; // 

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

[apiInstance getEntityHeadersWith:tagUpdateStartTime
              completionHandler: ^(AtlasEntityHeaders output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var tagUpdateStartTime = 789;  // Long | 

            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');

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::EntityRESTApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
tagUpdateStartTime = 789 # Long | 

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)

Parameters

Query parameters

Name	Description
tagUpdateStartTime*	Long (int64) Required

Responses

Status: 200 -

Schema

getHeaderById

Get entity header given its GUID.

/v2/entity/guid/{guid}/header

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/entity/guid/{guid}/header"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

String *guid = guid_example; // GUID for the entity

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var guid = guid_example;  // String | GUID for the entity

            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');

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::EntityRESTApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
guid = guid_example # String | GUID for the entity

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)

Parameters

Path parameters

Name	Description
guid*	String GUID for the entity Required

Responses

Status: 200 - AtlasEntity

Schema

importBMAttributes

Upload the file for creating Business Metadata in BULK

/v2/entity/businessmetadata/import

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: multipart/form-data"\
"/api/atlas//v2/entity/businessmetadata/import"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

public class EntityRESTApiExample {

    public static void main(String[] args) {
        
        EntityRESTApi apiInstance = new EntityRESTApi();
        byte[] fileDetail = fileDetail_example; // byte[] | 
        byte[] uploadedInputStream = uploadedInputStream_example; // byte[] | 
        try {
            BulkImportResponse result = apiInstance.importBMAttributes(fileDetail, uploadedInputStream);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#importBMAttributes");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EntityRESTApi;

public class EntityRESTApiExample {

    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        byte[] fileDetail = fileDetail_example; // byte[] | 
        byte[] uploadedInputStream = uploadedInputStream_example; // byte[] | 
        try {
            BulkImportResponse result = apiInstance.importBMAttributes(fileDetail, uploadedInputStream);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#importBMAttributes");
            e.printStackTrace();
        }
    }
}

byte[] *fileDetail = fileDetail_example; //  (optional)
byte[] *uploadedInputStream = uploadedInputStream_example; //  (optional)

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

[apiInstance importBMAttributesWith:fileDetail
    uploadedInputStream:uploadedInputStream
              completionHandler: ^(BulkImportResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.EntityRESTApi()
var opts = { 
  'fileDetail': fileDetail_example // {{byte[]}} 
  'uploadedInputStream': uploadedInputStream_example // {{byte[]}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.importBMAttributes(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var fileDetail = fileDetail_example;  // byte[] |  (optional) 
            var uploadedInputStream = uploadedInputStream_example;  // byte[] |  (optional) 

            try
            {
                BulkImportResponse result = apiInstance.importBMAttributes(fileDetail, uploadedInputStream);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EntityRESTApi.importBMAttributes: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$fileDetail = fileDetail_example; // byte[] | 
$uploadedInputStream = uploadedInputStream_example; // byte[] | 

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

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

my $api_instance = WWW::SwaggerClient::EntityRESTApi->new();
my $fileDetail = fileDetail_example; # byte[] | 
my $uploadedInputStream = uploadedInputStream_example; # byte[] | 

eval { 
    my $result = $api_instance->importBMAttributes(fileDetail => $fileDetail, uploadedInputStream => $uploadedInputStream);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->importBMAttributes: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
fileDetail = fileDetail_example # byte[] |  (optional)
uploadedInputStream = uploadedInputStream_example # byte[] |  (optional)

try: 
    api_response = api_instance.import_bm_attributes(fileDetail=fileDetail, uploadedInputStream=uploadedInputStream)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EntityRESTApi->importBMAttributes: %s\n" % e)

Parameters

Form parameters

Name	Description
fileDetail	byte[] (binary)
uploadedInputStream	byte[] (binary)

Responses

Status: 200 - If Business Metadata creation was successful

Schema

Status: 400 - If Business Metadata definition has invalid or missing information

Status: 409 - If Business Metadata already exists (duplicate qualifiedName)

partialUpdateEntityAttrByGuid

Entity Partial Update - Add/Update entity attribute identified by its GUID. Supports only uprimitive attribute type and entity references. does not support updation of complex types like arrays, maps Null updates are not possible

/v2/entity/guid/{guid}

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/api/atlas//v2/entity/guid/{guid}?name="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

public class EntityRESTApiExample {

    public static void main(String[] args) {
        
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | 
        File body = ; // File | 
        String name = name_example; // String | 
        try {
            EntityMutationResponse result = apiInstance.partialUpdateEntityAttrByGuid(guid, body, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#partialUpdateEntityAttrByGuid");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EntityRESTApi;

public class EntityRESTApiExample {

    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | 
        File body = ; // File | 
        String name = name_example; // String | 
        try {
            EntityMutationResponse result = apiInstance.partialUpdateEntityAttrByGuid(guid, body, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#partialUpdateEntityAttrByGuid");
            e.printStackTrace();
        }
    }
}

String *guid = guid_example; // 
File *body = ; //  (optional)
String *name = name_example; //  (optional)

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

[apiInstance partialUpdateEntityAttrByGuidWith:guid
    body:body
    name:name
              completionHandler: ^(EntityMutationResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.EntityRESTApi()
var guid = guid_example; // {{String}} 
var opts = { 
  'body':  // {{File}} 
  'name': name_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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var guid = guid_example;  // String | 
            var body = new File(); // File |  (optional) 
            var name = name_example;  // String |  (optional) 

            try
            {
                EntityMutationResponse result = apiInstance.partialUpdateEntityAttrByGuid(guid, body, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EntityRESTApi.partialUpdateEntityAttrByGuid: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$guid = guid_example; // String | 
$body = ; // File | 
$name = name_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::EntityRESTApi->new();
my $guid = guid_example; # String | 
my $body = WWW::SwaggerClient::Object::File->new(); # File | 
my $name = name_example; # String | 

eval { 
    my $result = $api_instance->partialUpdateEntityAttrByGuid(guid => $guid, body => $body, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->partialUpdateEntityAttrByGuid: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
guid = guid_example # String | 
body =  # File |  (optional)
name = name_example # String |  (optional)

try: 
    api_response = api_instance.partial_update_entity_attr_by_guid(guid, body=body, name=name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EntityRESTApi->partialUpdateEntityAttrByGuid: %s\n" % e)

Parameters

Path parameters

Name	Description
guid*	String Required

Body parameters

Name	Description
body

Query parameters

Name	Description
name	String

Responses

Status: 204 -

Schema

partialUpdateEntityByUniqueAttrs

Entity Partial Update - Allows a subset of attributes to be updated on an entity which is identified by its type and unique attribute eg: Referenceable.qualifiedName. Null updates are not possible In addition to the typeName path parameter, attribute key-value pair(s) can be provided in the following format attr:<attrName>=<attrValue> NOTE: The attrName and attrValue should be unique across entities, eg. qualifiedName The REST request would look something like this PUT /v2/entity/uniqueAttribute/type/aType?attr:aTypeAttribute=someValue

/v2/entity/uniqueAttribute/type/{typeName}

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/api/atlas//v2/entity/uniqueAttribute/type/{typeName}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

public class EntityRESTApiExample {

    public static void main(String[] args) {
        
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | 
        AtlasEntityWithExtInfo body = ; // AtlasEntityWithExtInfo | 
        try {
            EntityMutationResponse result = apiInstance.partialUpdateEntityByUniqueAttrs(typeName, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#partialUpdateEntityByUniqueAttrs");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EntityRESTApi;

public class EntityRESTApiExample {

    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | 
        AtlasEntityWithExtInfo body = ; // AtlasEntityWithExtInfo | 
        try {
            EntityMutationResponse result = apiInstance.partialUpdateEntityByUniqueAttrs(typeName, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#partialUpdateEntityByUniqueAttrs");
            e.printStackTrace();
        }
    }
}

String *typeName = typeName_example; // 
AtlasEntityWithExtInfo *body = ; //  (optional)

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.EntityRESTApi()
var typeName = typeName_example; // {{String}} 
var opts = { 
  'body':  // {{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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var typeName = typeName_example;  // String | 
            var body = new AtlasEntityWithExtInfo(); // AtlasEntityWithExtInfo |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$typeName = typeName_example; // String | 
$body = ; // AtlasEntityWithExtInfo | 

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

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

my $api_instance = WWW::SwaggerClient::EntityRESTApi->new();
my $typeName = typeName_example; # String | 
my $body = WWW::SwaggerClient::Object::AtlasEntityWithExtInfo->new(); # AtlasEntityWithExtInfo | 

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

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

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
typeName = typeName_example # String | 
body =  # AtlasEntityWithExtInfo |  (optional)

try: 
    api_response = api_instance.partial_update_entity_by_unique_attrs(typeName, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EntityRESTApi->partialUpdateEntityByUniqueAttrs: %s\n" % e)

Parameters

Path parameters

Name	Description
typeName*	String Required

Body parameters

Name	Description
body

Responses

Status: 204 -

Schema

produceTemplate

Get the sample Template for uploading/creating bulk BusinessMetaData

/v2/entity/businessmetadata/import/template

Usage and SDK Samples

curl -X GET\
-H "Accept: application/octet-stream"\
"/api/atlas//v2/entity/businessmetadata/import/template"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

public class EntityRESTApiExample {

    public static void main(String[] args) {
        
        EntityRESTApi apiInstance = new EntityRESTApi();
        try {
            byte[] result = apiInstance.produceTemplate();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#produceTemplate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EntityRESTApi;

public class EntityRESTApiExample {

    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        try {
            byte[] result = apiInstance.produceTemplate();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#produceTemplate");
            e.printStackTrace();
        }
    }
}


EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();

            try
            {
                byte[] 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');

$api_instance = new Swagger\Client\ApiEntityRESTApi();

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::SwaggerClient::Configuration;
use WWW::SwaggerClient::EntityRESTApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_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)

Parameters

Responses

Status: 200 - Template File

Schema

Status: 400 - If the provided fileType is not supported

removeBusinessAttributes

/v2/entity/guid/{guid}/businessmetadata

Usage and SDK Samples

curl -X DELETE\
-H "Content-Type: application/json"\
"/api/atlas//v2/entity/guid/{guid}/businessmetadata"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

public class EntityRESTApiExample {

    public static void main(String[] args) {
        
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | 
        map[String, Object] body = ; // map[String, Object] | 
        try {
            apiInstance.removeBusinessAttributes(guid, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#removeBusinessAttributes");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EntityRESTApi;

public class EntityRESTApiExample {

    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | 
        map[String, Object] body = ; // map[String, Object] | 
        try {
            apiInstance.removeBusinessAttributes(guid, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#removeBusinessAttributes");
            e.printStackTrace();
        }
    }
}

String *guid = guid_example; // 
map[String, Object] *body = ; //  (optional)

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.EntityRESTApi()
var guid = guid_example; // {{String}} 
var opts = { 
  'body':  // {{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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var guid = guid_example;  // String | 
            var body = new map[String, Object](); // map[String, Object] |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$guid = guid_example; // String | 
$body = ; // map[String, Object] | 

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

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

my $api_instance = WWW::SwaggerClient::EntityRESTApi->new();
my $guid = guid_example; # String | 
my $body = WWW::SwaggerClient::Object::map[String, Object]->new(); # map[String, Object] | 

eval { 
    $api_instance->removeBusinessAttributes(guid => $guid, body => $body);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->removeBusinessAttributes: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
guid = guid_example # String | 
body =  # map[String, Object] |  (optional)

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

Parameters

Path parameters

Name	Description
guid*	String Required

Body parameters

Name	Description
body

Responses

Status: 204 - Success

removeBusinessAttributes_4

/v2/entity/guid/{guid}/businessmetadata/{bmName}

Usage and SDK Samples

curl -X DELETE\
-H "Content-Type: application/json"\
"/api/atlas//v2/entity/guid/{guid}/businessmetadata/{bmName}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

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] body = ; // map[String, Object] | 
        try {
            apiInstance.removeBusinessAttributes_0(bmName, guid, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#removeBusinessAttributes_0");
            e.printStackTrace();
        }
    }
}

import io.swagger.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] body = ; // map[String, Object] | 
        try {
            apiInstance.removeBusinessAttributes_0(bmName, guid, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#removeBusinessAttributes_0");
            e.printStackTrace();
        }
    }
}

String *bmName = bmName_example; // 
String *guid = guid_example; // 
map[String, Object] *body = ; //  (optional)

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.EntityRESTApi()
var bmName = bmName_example; // {{String}} 
var guid = guid_example; // {{String}} 
var opts = { 
  'body':  // {{map[String, Object]}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.removeBusinessAttributes_0(bmNameguid, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var bmName = bmName_example;  // String | 
            var guid = guid_example;  // String | 
            var body = new map[String, Object](); // map[String, Object] |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$bmName = bmName_example; // String | 
$guid = guid_example; // String | 
$body = ; // map[String, Object] | 

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

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

my $api_instance = WWW::SwaggerClient::EntityRESTApi->new();
my $bmName = bmName_example; # String | 
my $guid = guid_example; # String | 
my $body = WWW::SwaggerClient::Object::map[String, Object]->new(); # map[String, Object] | 

eval { 
    $api_instance->removeBusinessAttributes_0(bmName => $bmName, guid => $guid, body => $body);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->removeBusinessAttributes_0: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
bmName = bmName_example # String | 
guid = guid_example # String | 
body =  # map[String, Object] |  (optional)

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

Parameters

Path parameters

Name	Description
bmName*	String Required
guid*	String Required

Body parameters

Name	Description
body

Responses

Status: 204 - Success

removeLabels

delete given labels to a given entity

/v2/entity/guid/{guid}/labels

Usage and SDK Samples

curl -X DELETE\
-H "Content-Type: application/json"\
"/api/atlas//v2/entity/guid/{guid}/labels"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

public class EntityRESTApiExample {

    public static void main(String[] args) {
        
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | - Unique entity identifier
        array[String] body = ; // array[String] | 
        try {
            apiInstance.removeLabels(guid, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#removeLabels");
            e.printStackTrace();
        }
    }
}

import io.swagger.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] body = ; // array[String] | 
        try {
            apiInstance.removeLabels(guid, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#removeLabels");
            e.printStackTrace();
        }
    }
}

String *guid = guid_example; // - Unique entity identifier
array[String] *body = ; //  (optional)

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.EntityRESTApi()
var guid = guid_example; // {{String}} - Unique entity identifier
var opts = { 
  'body':  // {{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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var guid = guid_example;  // String | - Unique entity identifier
            var body = new array[String](); // array[String] |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$guid = guid_example; // String | - Unique entity identifier
$body = ; // array[String] | 

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

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

my $api_instance = WWW::SwaggerClient::EntityRESTApi->new();
my $guid = guid_example; # String | - Unique entity identifier
my $body = [WWW::SwaggerClient::Object::array[String]->new()]; # array[String] | 

eval { 
    $api_instance->removeLabels(guid => $guid, body => $body);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->removeLabels: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
guid = guid_example # String | - Unique entity identifier
body =  # array[String] |  (optional)

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

Parameters

Path parameters

Name	Description
guid*	String - Unique entity identifier Required

Body parameters

Name	Description
body

Responses

Status: 204 - Success

removeLabels_5

/v2/entity/uniqueAttribute/type/{typeName}/labels

Usage and SDK Samples

curl -X DELETE\
-H "Content-Type: application/json"\
"/api/atlas//v2/entity/uniqueAttribute/type/{typeName}/labels"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

public class EntityRESTApiExample {

    public static void main(String[] args) {
        
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | 
        array[String] body = ; // array[String] | 
        try {
            apiInstance.removeLabels_0(typeName, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#removeLabels_0");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EntityRESTApi;

public class EntityRESTApiExample {

    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | 
        array[String] body = ; // array[String] | 
        try {
            apiInstance.removeLabels_0(typeName, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#removeLabels_0");
            e.printStackTrace();
        }
    }
}

String *typeName = typeName_example; // 
array[String] *body = ; //  (optional)

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.EntityRESTApi()
var typeName = typeName_example; // {{String}} 
var opts = { 
  'body':  // {{array[String]}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.removeLabels_0(typeName, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var typeName = typeName_example;  // String | 
            var body = new array[String](); // array[String] |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$typeName = typeName_example; // String | 
$body = ; // array[String] | 

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

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

my $api_instance = WWW::SwaggerClient::EntityRESTApi->new();
my $typeName = typeName_example; # String | 
my $body = [WWW::SwaggerClient::Object::array[String]->new()]; # array[String] | 

eval { 
    $api_instance->removeLabels_0(typeName => $typeName, body => $body);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->removeLabels_0: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
typeName = typeName_example # String | 
body =  # array[String] |  (optional)

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

Parameters

Path parameters

Name	Description
typeName*	String Required

Body parameters

Name	Description
body

Responses

Status: 204 - Success

setClassifications

/v2/entity/bulk/setClassifications

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/api/atlas//v2/entity/bulk/setClassifications"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

public class EntityRESTApiExample {

    public static void main(String[] args) {
        
        EntityRESTApi apiInstance = new EntityRESTApi();
        AtlasEntityHeaders body = ; // AtlasEntityHeaders | 
        try {
            'String' result = apiInstance.setClassifications(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#setClassifications");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EntityRESTApi;

public class EntityRESTApiExample {

    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        AtlasEntityHeaders body = ; // AtlasEntityHeaders | 
        try {
            'String' result = apiInstance.setClassifications(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#setClassifications");
            e.printStackTrace();
        }
    }
}

AtlasEntityHeaders *body = ; //  (optional)

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.EntityRESTApi()
var opts = { 
  'body':  // {{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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var body = new AtlasEntityHeaders(); // AtlasEntityHeaders |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$body = ; // AtlasEntityHeaders | 

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

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

my $api_instance = WWW::SwaggerClient::EntityRESTApi->new();
my $body = WWW::SwaggerClient::Object::AtlasEntityHeaders->new(); # AtlasEntityHeaders | 

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

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

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
body =  # AtlasEntityHeaders |  (optional)

try: 
    api_response = api_instance.set_classifications(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EntityRESTApi->setClassifications: %s\n" % e)

Parameters

Body parameters

Name	Description
body

Responses

Status: 201 -

Schema

setLabels

Set labels to a given entity

/v2/entity/guid/{guid}/labels

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json"\
"/api/atlas//v2/entity/guid/{guid}/labels"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

public class EntityRESTApiExample {

    public static void main(String[] args) {
        
        EntityRESTApi apiInstance = new EntityRESTApi();
        String guid = guid_example; // String | - Unique entity identifier
        array[String] body = ; // array[String] | - set of labels to be set to the entity
        try {
            apiInstance.setLabels(guid, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#setLabels");
            e.printStackTrace();
        }
    }
}

import io.swagger.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] body = ; // array[String] | - set of labels to be set to the entity
        try {
            apiInstance.setLabels(guid, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#setLabels");
            e.printStackTrace();
        }
    }
}

String *guid = guid_example; // - Unique entity identifier
array[String] *body = ; // - set of labels to be set to the entity (optional)

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.EntityRESTApi()
var guid = guid_example; // {{String}} - Unique entity identifier
var opts = { 
  'body':  // {{array[String]}} - set of labels to be set to the entity
};
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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var guid = guid_example;  // String | - Unique entity identifier
            var body = new array[String](); // array[String] | - set of labels to be set to the entity (optional) 

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

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

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$guid = guid_example; // String | - Unique entity identifier
$body = ; // array[String] | - set of labels to be set to the entity

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

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

my $api_instance = WWW::SwaggerClient::EntityRESTApi->new();
my $guid = guid_example; # String | - Unique entity identifier
my $body = [WWW::SwaggerClient::Object::array[String]->new()]; # array[String] | - set of labels to be set to the entity

eval { 
    $api_instance->setLabels(guid => $guid, body => $body);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->setLabels: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
guid = guid_example # String | - Unique entity identifier
body =  # array[String] | - set of labels to be set to the entity (optional)

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

Parameters

Path parameters

Name	Description
guid*	String - Unique entity identifier Required

Body parameters

Name	Description
body

Responses

Status: 201 - Success

setLabels_6

/v2/entity/uniqueAttribute/type/{typeName}/labels

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json"\
"/api/atlas//v2/entity/uniqueAttribute/type/{typeName}/labels"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

public class EntityRESTApiExample {

    public static void main(String[] args) {
        
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | 
        array[String] body = ; // array[String] | 
        try {
            apiInstance.setLabels_0(typeName, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#setLabels_0");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EntityRESTApi;

public class EntityRESTApiExample {

    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | 
        array[String] body = ; // array[String] | 
        try {
            apiInstance.setLabels_0(typeName, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#setLabels_0");
            e.printStackTrace();
        }
    }
}

String *typeName = typeName_example; // 
array[String] *body = ; //  (optional)

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.EntityRESTApi()
var typeName = typeName_example; // {{String}} 
var opts = { 
  'body':  // {{array[String]}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.setLabels_0(typeName, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var typeName = typeName_example;  // String | 
            var body = new array[String](); // array[String] |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$typeName = typeName_example; // String | 
$body = ; // array[String] | 

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

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

my $api_instance = WWW::SwaggerClient::EntityRESTApi->new();
my $typeName = typeName_example; # String | 
my $body = [WWW::SwaggerClient::Object::array[String]->new()]; # array[String] | 

eval { 
    $api_instance->setLabels_0(typeName => $typeName, body => $body);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->setLabels_0: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
typeName = typeName_example # String | 
body =  # array[String] |  (optional)

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

Parameters

Path parameters

Name	Description
typeName*	String Required

Body parameters

Name	Description
body

Responses

Status: 201 - Success

updateClassifications

Updates classifications to an existing entity represented by a guid.

/v2/entity/guid/{guid}/classifications

Usage and SDK Samples

curl -X PUT\
-H "Content-Type: application/json"\
"/api/atlas//v2/entity/guid/{guid}/classifications"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

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] body = ; // array[AtlasClassification] | 
        try {
            apiInstance.updateClassifications(guid, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#updateClassifications");
            e.printStackTrace();
        }
    }
}

import io.swagger.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] body = ; // array[AtlasClassification] | 
        try {
            apiInstance.updateClassifications(guid, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#updateClassifications");
            e.printStackTrace();
        }
    }
}

String *guid = guid_example; // globally unique identifier for the entity
array[AtlasClassification] *body = ; //  (optional)

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.EntityRESTApi()
var guid = guid_example; // {{String}} globally unique identifier for the entity
var opts = { 
  'body':  // {{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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var guid = guid_example;  // String | globally unique identifier for the entity
            var body = new array[AtlasClassification](); // array[AtlasClassification] |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$guid = guid_example; // String | globally unique identifier for the entity
$body = ; // array[AtlasClassification] | 

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

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

my $api_instance = WWW::SwaggerClient::EntityRESTApi->new();
my $guid = guid_example; # String | globally unique identifier for the entity
my $body = [WWW::SwaggerClient::Object::array[AtlasClassification]->new()]; # array[AtlasClassification] | 

eval { 
    $api_instance->updateClassifications(guid => $guid, body => $body);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->updateClassifications: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
guid = guid_example # String | globally unique identifier for the entity
body =  # array[AtlasClassification] |  (optional)

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

Parameters

Path parameters

Name	Description
guid*	String globally unique identifier for the entity Required

Body parameters

Name	Description
body

Responses

Status: 204 - Success

updateClassificationsByUniqueAttribute

Updates classification on an entity identified by its type and unique attributes.

/v2/entity/uniqueAttribute/type/{typeName}/classifications

Usage and SDK Samples

curl -X PUT\
-H "Content-Type: application/json"\
"/api/atlas//v2/entity/uniqueAttribute/type/{typeName}/classifications"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EntityRESTApi;

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

public class EntityRESTApiExample {

    public static void main(String[] args) {
        
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | 
        array[AtlasClassification] body = ; // array[AtlasClassification] | 
        try {
            apiInstance.updateClassificationsByUniqueAttribute(typeName, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#updateClassificationsByUniqueAttribute");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EntityRESTApi;

public class EntityRESTApiExample {

    public static void main(String[] args) {
        EntityRESTApi apiInstance = new EntityRESTApi();
        String typeName = typeName_example; // String | 
        array[AtlasClassification] body = ; // array[AtlasClassification] | 
        try {
            apiInstance.updateClassificationsByUniqueAttribute(typeName, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling EntityRESTApi#updateClassificationsByUniqueAttribute");
            e.printStackTrace();
        }
    }
}

String *typeName = typeName_example; // 
array[AtlasClassification] *body = ; //  (optional)

EntityRESTApi *apiInstance = [[EntityRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.EntityRESTApi()
var typeName = typeName_example; // {{String}} 
var opts = { 
  'body':  // {{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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new EntityRESTApi();
            var typeName = typeName_example;  // String | 
            var body = new array[AtlasClassification](); // array[AtlasClassification] |  (optional) 

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

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

$api_instance = new Swagger\Client\ApiEntityRESTApi();
$typeName = typeName_example; // String | 
$body = ; // array[AtlasClassification] | 

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

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

my $api_instance = WWW::SwaggerClient::EntityRESTApi->new();
my $typeName = typeName_example; # String | 
my $body = [WWW::SwaggerClient::Object::array[AtlasClassification]->new()]; # array[AtlasClassification] | 

eval { 
    $api_instance->updateClassificationsByUniqueAttribute(typeName => $typeName, body => $body);
};
if ($@) {
    warn "Exception when calling EntityRESTApi->updateClassificationsByUniqueAttribute: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.EntityRESTApi()
typeName = typeName_example # String | 
body =  # array[AtlasClassification] |  (optional)

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

Parameters

Path parameters

Name	Description
typeName*	String Required

Body parameters

Name	Description
body

Responses

Status: 204 - Success

GlossaryREST

assignTermToEntities

Assign the given term to the provided list of entity headers

/v2/glossary/terms/{termGuid}/assignedEntities

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json"\
"/api/atlas//v2/glossary/terms/{termGuid}/assignedEntities"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String termGuid = termGuid_example; // String | Glossary term GUID
        array[AtlasRelatedObjectId] body = ; // array[AtlasRelatedObjectId] | Related Entity IDs to which the term has to be associated
        try {
            apiInstance.assignTermToEntities(termGuid, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#assignTermToEntities");
            e.printStackTrace();
        }
    }
}

import io.swagger.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] body = ; // array[AtlasRelatedObjectId] | Related Entity IDs to which the term has to be associated
        try {
            apiInstance.assignTermToEntities(termGuid, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#assignTermToEntities");
            e.printStackTrace();
        }
    }
}

String *termGuid = termGuid_example; // Glossary term GUID
array[AtlasRelatedObjectId] *body = ; // Related Entity IDs to which the term has to be associated (optional)

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.GlossaryRESTApi()
var termGuid = termGuid_example; // {{String}} Glossary term GUID
var opts = { 
  'body':  // {{array[AtlasRelatedObjectId]}} Related Entity IDs to which the term has to be associated
};
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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var termGuid = termGuid_example;  // String | Glossary term GUID
            var body = new array[AtlasRelatedObjectId](); // array[AtlasRelatedObjectId] | Related Entity IDs to which the term has to be associated (optional) 

            try
            {
                apiInstance.assignTermToEntities(termGuid, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.assignTermToEntities: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$termGuid = termGuid_example; // String | Glossary term GUID
$body = ; // array[AtlasRelatedObjectId] | Related Entity IDs to which the term has to be associated

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::GlossaryRESTApi->new();
my $termGuid = termGuid_example; # String | Glossary term GUID
my $body = [WWW::SwaggerClient::Object::array[AtlasRelatedObjectId]->new()]; # array[AtlasRelatedObjectId] | Related Entity IDs to which the term has to be associated

eval { 
    $api_instance->assignTermToEntities(termGuid => $termGuid, body => $body);
};
if ($@) {
    warn "Exception when calling GlossaryRESTApi->assignTermToEntities: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
termGuid = termGuid_example # String | Glossary term GUID
body =  # array[AtlasRelatedObjectId] | Related Entity IDs to which the term has to be associated (optional)

try: 
    api_instance.assign_term_to_entities(termGuid, body=body)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->assignTermToEntities: %s\n" % e)

Parameters

Path parameters

Name	Description
termGuid*	String Glossary term GUID Required

Body parameters

Name	Description
body

Responses

Status: 204 - If the term assignment was successful

Status: 400 - If ANY of the entity header is invalid

Status: 404 - If glossary guid in invalid

createGlossary

Create a glossary

/v2/glossary

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/api/atlas//v2/glossary"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        AtlasGlossary body = ; // AtlasGlossary | Glossary definition, terms & categories can be anchored to a glossary
using the anchor attribute when creating the Term/Category
        try {
            AtlasGlossary result = apiInstance.createGlossary(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#createGlossary");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GlossaryRESTApi;

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        AtlasGlossary body = ; // AtlasGlossary | Glossary definition, terms & categories can be anchored to a glossary
using the anchor attribute when creating the Term/Category
        try {
            AtlasGlossary result = apiInstance.createGlossary(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#createGlossary");
            e.printStackTrace();
        }
    }
}

AtlasGlossary *body = ; // Glossary definition, terms & categories can be anchored to a glossary
using the anchor attribute when creating the Term/Category (optional)

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

[apiInstance createGlossaryWith:body
              completionHandler: ^(AtlasGlossary output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.GlossaryRESTApi()
var opts = { 
  'body':  // {{AtlasGlossary}} Glossary definition, terms & categories can be anchored to a glossary
using the anchor attribute when creating the Term/Category
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createGlossary(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var body = new AtlasGlossary(); // AtlasGlossary | Glossary definition, terms & categories can be anchored to a glossary
using the anchor attribute when creating the Term/Category (optional) 

            try
            {
                AtlasGlossary result = apiInstance.createGlossary(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.createGlossary: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$body = ; // AtlasGlossary | Glossary definition, terms & categories can be anchored to a glossary
using the anchor attribute when creating the Term/Category

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::GlossaryRESTApi->new();
my $body = WWW::SwaggerClient::Object::AtlasGlossary->new(); # AtlasGlossary | Glossary definition, terms & categories can be anchored to a glossary
using the anchor attribute when creating the Term/Category

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

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

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
body =  # AtlasGlossary | Glossary definition, terms & categories can be anchored to a glossary
using the anchor attribute when creating the Term/Category (optional)

try: 
    api_response = api_instance.create_glossary(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->createGlossary: %s\n" % e)

Parameters

Body parameters

Name	Description
body

Responses

Status: 200 - If glossary creation was successful

Schema

Status: 400 - If Glossary definition has invalid or missing information

Status: 409 - If Glossary definition already exists (duplicate qualifiedName)

createGlossaryCategories

Create glossary category in bulk

/v2/glossary/categories

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/api/atlas//v2/glossary/categories"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        array[AtlasGlossaryCategory] body = ; // array[AtlasGlossaryCategory] | glossary category definitions
        try {
            array[AtlasGlossaryCategory] result = apiInstance.createGlossaryCategories(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#createGlossaryCategories");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GlossaryRESTApi;

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        array[AtlasGlossaryCategory] body = ; // array[AtlasGlossaryCategory] | glossary category definitions
        try {
            array[AtlasGlossaryCategory] result = apiInstance.createGlossaryCategories(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#createGlossaryCategories");
            e.printStackTrace();
        }
    }
}

array[AtlasGlossaryCategory] *body = ; // glossary category definitions (optional)

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

[apiInstance createGlossaryCategoriesWith:body
              completionHandler: ^(array[AtlasGlossaryCategory] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.GlossaryRESTApi()
var opts = { 
  'body':  // {{array[AtlasGlossaryCategory]}} glossary category definitions
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createGlossaryCategories(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var body = new array[AtlasGlossaryCategory](); // array[AtlasGlossaryCategory] | glossary category definitions (optional) 

            try
            {
                array[AtlasGlossaryCategory] result = apiInstance.createGlossaryCategories(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.createGlossaryCategories: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$body = ; // array[AtlasGlossaryCategory] | glossary category definitions

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::GlossaryRESTApi->new();
my $body = [WWW::SwaggerClient::Object::array[AtlasGlossaryCategory]->new()]; # array[AtlasGlossaryCategory] | glossary category definitions

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

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

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
body =  # array[AtlasGlossaryCategory] | glossary category definitions (optional)

try: 
    api_response = api_instance.create_glossary_categories(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->createGlossaryCategories: %s\n" % e)

Parameters

Body parameters

Name	Description
body

Responses

Status: 200 - If BULK glossary category creation was successful

Schema

Status: 400 - If ANY Glossary category definition has invalid or missing information

createGlossaryCategory

Create glossary category

/v2/glossary/category

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/api/atlas//v2/glossary/category"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        AtlasGlossaryCategory body = ; // AtlasGlossaryCategory | glossary category definition, a category must be anchored to a Glossary when creating
Optionally, terms belonging to the category and the hierarchy can also be defined during creation
        try {
            AtlasGlossaryCategory result = apiInstance.createGlossaryCategory(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#createGlossaryCategory");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GlossaryRESTApi;

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        AtlasGlossaryCategory body = ; // AtlasGlossaryCategory | glossary category definition, a category must be anchored to a Glossary when creating
Optionally, terms belonging to the category and the hierarchy can also be defined during creation
        try {
            AtlasGlossaryCategory result = apiInstance.createGlossaryCategory(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#createGlossaryCategory");
            e.printStackTrace();
        }
    }
}

AtlasGlossaryCategory *body = ; // glossary category definition, a category must be anchored to a Glossary when creating
Optionally, terms belonging to the category and the hierarchy can also be defined during creation (optional)

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

[apiInstance createGlossaryCategoryWith:body
              completionHandler: ^(AtlasGlossaryCategory output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.GlossaryRESTApi()
var opts = { 
  'body':  // {{AtlasGlossaryCategory}} glossary category definition, a category must be anchored to a Glossary when creating
Optionally, terms belonging to the category and the hierarchy can also be defined during creation
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createGlossaryCategory(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var body = new AtlasGlossaryCategory(); // AtlasGlossaryCategory | glossary category definition, a category must be anchored to a Glossary when creating
Optionally, terms belonging to the category and the hierarchy can also be defined during creation (optional) 

            try
            {
                AtlasGlossaryCategory result = apiInstance.createGlossaryCategory(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.createGlossaryCategory: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$body = ; // AtlasGlossaryCategory | glossary category definition, a category must be anchored to a Glossary when creating
Optionally, terms belonging to the category and the hierarchy can also be defined during creation

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::GlossaryRESTApi->new();
my $body = WWW::SwaggerClient::Object::AtlasGlossaryCategory->new(); # AtlasGlossaryCategory | glossary category definition, a category must be anchored to a Glossary when creating
Optionally, terms belonging to the category and the hierarchy can also be defined during creation

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

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

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
body =  # AtlasGlossaryCategory | glossary category definition, a category must be anchored to a Glossary when creating
Optionally, terms belonging to the category and the hierarchy can also be defined during creation (optional)

try: 
    api_response = api_instance.create_glossary_category(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->createGlossaryCategory: %s\n" % e)

Parameters

Body parameters

Name	Description
body

Responses

Status: 200 - If glossary category creation was successful

Schema

Status: 400 - If Glossary category definition has invalid or missing information

Status: 409 - If Glossary category already exists (duplicate qualifiedName)

createGlossaryTerm

Create a glossary term

/v2/glossary/term

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/api/atlas//v2/glossary/term"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        AtlasGlossaryTerm body = ; // AtlasGlossaryTerm | Glossary term definition, a term must be anchored to a Glossary at the time of creation
optionally it can be categorized as well
        try {
            AtlasGlossaryTerm result = apiInstance.createGlossaryTerm(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#createGlossaryTerm");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GlossaryRESTApi;

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        AtlasGlossaryTerm body = ; // AtlasGlossaryTerm | Glossary term definition, a term must be anchored to a Glossary at the time of creation
optionally it can be categorized as well
        try {
            AtlasGlossaryTerm result = apiInstance.createGlossaryTerm(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#createGlossaryTerm");
            e.printStackTrace();
        }
    }
}

AtlasGlossaryTerm *body = ; // Glossary term definition, a term must be anchored to a Glossary at the time of creation
optionally it can be categorized as well (optional)

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

[apiInstance createGlossaryTermWith:body
              completionHandler: ^(AtlasGlossaryTerm output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.GlossaryRESTApi()
var opts = { 
  'body':  // {{AtlasGlossaryTerm}} Glossary term definition, a term must be anchored to a Glossary at the time of creation
optionally it can be categorized as well
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createGlossaryTerm(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var body = new AtlasGlossaryTerm(); // AtlasGlossaryTerm | Glossary term definition, a term must be anchored to a Glossary at the time of creation
optionally it can be categorized as well (optional) 

            try
            {
                AtlasGlossaryTerm result = apiInstance.createGlossaryTerm(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.createGlossaryTerm: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$body = ; // AtlasGlossaryTerm | Glossary term definition, a term must be anchored to a Glossary at the time of creation
optionally it can be categorized as well

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::GlossaryRESTApi->new();
my $body = WWW::SwaggerClient::Object::AtlasGlossaryTerm->new(); # AtlasGlossaryTerm | Glossary term definition, a term must be anchored to a Glossary at the time of creation
optionally it can be categorized as well

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

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

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
body =  # AtlasGlossaryTerm | Glossary term definition, a term must be anchored to a Glossary at the time of creation
optionally it can be categorized as well (optional)

try: 
    api_response = api_instance.create_glossary_term(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->createGlossaryTerm: %s\n" % e)

Parameters

Body parameters

Name	Description
body

Responses

Status: 200 - If glossary term creation was successful

Schema

Status: 400 - If Glossary term definition has invalid or missing information

Status: 409 - If Glossary term already exists (duplicate qualifiedName)

createGlossaryTerms

Create glossary terms in bulk

/v2/glossary/terms

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/api/atlas//v2/glossary/terms"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        array[AtlasGlossaryTerm] body = ; // array[AtlasGlossaryTerm] | glossary term definitions
        try {
            array[AtlasGlossaryTerm] result = apiInstance.createGlossaryTerms(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#createGlossaryTerms");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GlossaryRESTApi;

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        array[AtlasGlossaryTerm] body = ; // array[AtlasGlossaryTerm] | glossary term definitions
        try {
            array[AtlasGlossaryTerm] result = apiInstance.createGlossaryTerms(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#createGlossaryTerms");
            e.printStackTrace();
        }
    }
}

array[AtlasGlossaryTerm] *body = ; // glossary term definitions (optional)

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

[apiInstance createGlossaryTermsWith:body
              completionHandler: ^(array[AtlasGlossaryTerm] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.GlossaryRESTApi()
var opts = { 
  'body':  // {{array[AtlasGlossaryTerm]}} glossary term definitions
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createGlossaryTerms(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var body = new array[AtlasGlossaryTerm](); // array[AtlasGlossaryTerm] | glossary term definitions (optional) 

            try
            {
                array[AtlasGlossaryTerm] result = apiInstance.createGlossaryTerms(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.createGlossaryTerms: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$body = ; // array[AtlasGlossaryTerm] | glossary term definitions

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::GlossaryRESTApi->new();
my $body = [WWW::SwaggerClient::Object::array[AtlasGlossaryTerm]->new()]; # array[AtlasGlossaryTerm] | glossary term definitions

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

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

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
body =  # array[AtlasGlossaryTerm] | glossary term definitions (optional)

try: 
    api_response = api_instance.create_glossary_terms(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->createGlossaryTerms: %s\n" % e)

Parameters

Body parameters

Name	Description
body

Responses

Status: 200 - If Bulk glossary terms creation was successful

Schema

Status: 400 - If any glossary term definition has invalid or missing information

deleteGlossary

Delete a glossary

/v2/glossary/{glossaryGuid}

Usage and SDK Samples

curl -X DELETE\
"/api/atlas//v2/glossary/{glossaryGuid}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

String *glossaryGuid = glossaryGuid_example; // unique identifier for glossary

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var glossaryGuid = glossaryGuid_example;  // String | unique identifier for glossary

            try
            {
                apiInstance.deleteGlossary(glossaryGuid);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.deleteGlossary: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
glossaryGuid = glossaryGuid_example # String | unique identifier for glossary

try: 
    api_instance.delete_glossary(glossaryGuid)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->deleteGlossary: %s\n" % e)

Parameters

Path parameters

Name	Description
glossaryGuid*	String unique identifier for glossary Required

Responses

Status: 204 - If glossary delete was successful

Status: 404 - If glossary guid in invalid

deleteGlossaryCategory

Delete a glossary category

/v2/glossary/category/{categoryGuid}

Usage and SDK Samples

curl -X DELETE\
"/api/atlas//v2/glossary/category/{categoryGuid}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

String *categoryGuid = categoryGuid_example; // unique identifier for glossary category

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var categoryGuid = categoryGuid_example;  // String | unique identifier for glossary category

            try
            {
                apiInstance.deleteGlossaryCategory(categoryGuid);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.deleteGlossaryCategory: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
categoryGuid = categoryGuid_example # String | unique identifier for glossary category

try: 
    api_instance.delete_glossary_category(categoryGuid)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->deleteGlossaryCategory: %s\n" % e)

Parameters

Path parameters

Name	Description
categoryGuid*	String unique identifier for glossary category Required

Responses

Status: 204 - If glossary category delete was successful

Status: 404 - If glossary category guid in invalid

deleteGlossaryTerm

Delete a glossary term

/v2/glossary/term/{termGuid}

Usage and SDK Samples

curl -X DELETE\
"/api/atlas//v2/glossary/term/{termGuid}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

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();
        }
    }
}

import io.swagger.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();
        }
    }
}

String *termGuid = termGuid_example; // unique identifier for glossary term

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var termGuid = termGuid_example;  // String | unique identifier for glossary term

            try
            {
                apiInstance.deleteGlossaryTerm(termGuid);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.deleteGlossaryTerm: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::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 swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
termGuid = termGuid_example # String | unique identifier for glossary term

try: 
    api_instance.delete_glossary_term(termGuid)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->deleteGlossaryTerm: %s\n" % e)

Parameters

Path parameters

Name	Description
termGuid*	String unique identifier for glossary term Required

Responses

Status: 204 - If glossary term delete was successful

Status: 404 - If glossary term guid in invalid

disassociateTermAssignmentFromEntities

Remove the term assignment for the given list of entity headers

/v2/glossary/terms/{termGuid}/assignedEntities

Usage and SDK Samples

curl -X PUT\
-H "Content-Type: application/json"\
"/api/atlas//v2/glossary/terms/{termGuid}/assignedEntities"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String termGuid = termGuid_example; // String | Glossary term GUID
        array[AtlasRelatedObjectId] body = ; // array[AtlasRelatedObjectId] | List of related entity IDs from which the term has to be dissociated
        try {
            apiInstance.disassociateTermAssignmentFromEntities(termGuid, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#disassociateTermAssignmentFromEntities");
            e.printStackTrace();
        }
    }
}

import io.swagger.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] body = ; // array[AtlasRelatedObjectId] | List of related entity IDs from which the term has to be dissociated
        try {
            apiInstance.disassociateTermAssignmentFromEntities(termGuid, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#disassociateTermAssignmentFromEntities");
            e.printStackTrace();
        }
    }
}

String *termGuid = termGuid_example; // Glossary term GUID
array[AtlasRelatedObjectId] *body = ; // List of related entity IDs from which the term has to be dissociated (optional)

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.GlossaryRESTApi()
var termGuid = termGuid_example; // {{String}} Glossary term GUID
var opts = { 
  'body':  // {{array[AtlasRelatedObjectId]}} List of related entity IDs from which the term has to be dissociated
};
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 IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var termGuid = termGuid_example;  // String | Glossary term GUID
            var body = new array[AtlasRelatedObjectId](); // array[AtlasRelatedObjectId] | List of related entity IDs from which the term has to be dissociated (optional) 

            try
            {
                apiInstance.disassociateTermAssignmentFromEntities(termGuid, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.disassociateTermAssignmentFromEntities: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$termGuid = termGuid_example; // String | Glossary term GUID
$body = ; // array[AtlasRelatedObjectId] | List of related entity IDs from which the term has to be dissociated

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::GlossaryRESTApi->new();
my $termGuid = termGuid_example; # String | Glossary term GUID
my $body = [WWW::SwaggerClient::Object::array[AtlasRelatedObjectId]->new()]; # array[AtlasRelatedObjectId] | List of related entity IDs from which the term has to be dissociated

eval { 
    $api_instance->disassociateTermAssignmentFromEntities(termGuid => $termGuid, body => $body);
};
if ($@) {
    warn "Exception when calling GlossaryRESTApi->disassociateTermAssignmentFromEntities: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
termGuid = termGuid_example # String | Glossary term GUID
body =  # array[AtlasRelatedObjectId] | List of related entity IDs from which the term has to be dissociated (optional)

try: 
    api_instance.disassociate_term_assignment_from_entities(termGuid, body=body)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->disassociateTermAssignmentFromEntities: %s\n" % e)

Parameters

Path parameters

Name	Description
termGuid*	String Glossary term GUID Required

Body parameters

Name	Description
body

Responses

Status: 204 - If glossary term dissociation was successful

Status: 400 - If ANY of the entity header is invalid

Status: 404 - If glossary term guid in invalid

getCategoryTerms

Get all terms associated with the specific category

/v2/glossary/category/{categoryGuid}/terms

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/glossary/category/{categoryGuid}/terms?limit=&offset=&sort="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String categoryGuid = categoryGuid_example; // String | unique identifier for glossary category
        String limit = limit_example; // String | page size - by default there is no paging
        String offset = offset_example; // String | offset for pagination purpose
        String sort = sort_example; // String | ASC (default) or DESC
        try {
            array[AtlasRelatedTermHeader] result = apiInstance.getCategoryTerms(categoryGuid, limit, offset, sort);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#getCategoryTerms");
            e.printStackTrace();
        }
    }
}

import io.swagger.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
        String limit = limit_example; // String | page size - by default there is no paging
        String offset = offset_example; // String | offset for pagination purpose
        String sort = sort_example; // String | ASC (default) or DESC
        try {
            array[AtlasRelatedTermHeader] result = apiInstance.getCategoryTerms(categoryGuid, limit, offset, sort);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#getCategoryTerms");
            e.printStackTrace();
        }
    }
}

String *categoryGuid = categoryGuid_example; // unique identifier for glossary category
String *limit = limit_example; // page size - by default there is no paging (optional) (default to -1)
String *offset = offset_example; // offset for pagination purpose (optional) (default to 0)
String *sort = sort_example; // ASC (default) or DESC (optional) (default to ASC)

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

[apiInstance getCategoryTermsWith:categoryGuid
    limit:limit
    offset:offset
    sort:sort
              completionHandler: ^(array[AtlasRelatedTermHeader] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.GlossaryRESTApi()
var categoryGuid = categoryGuid_example; // {{String}} unique identifier for glossary category
var opts = { 
  'limit': limit_example, // {{String}} page size - by default there is no paging
  'offset': offset_example, // {{String}} offset for pagination purpose
  'sort': sort_example // {{String}} ASC (default) or DESC
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getCategoryTerms(categoryGuid, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var categoryGuid = categoryGuid_example;  // String | unique identifier for glossary category
            var limit = limit_example;  // String | page size - by default there is no paging (optional)  (default to -1)
            var offset = offset_example;  // String | offset for pagination purpose (optional)  (default to 0)
            var sort = sort_example;  // String | ASC (default) or DESC (optional)  (default to ASC)

            try
            {
                array[AtlasRelatedTermHeader] result = apiInstance.getCategoryTerms(categoryGuid, limit, offset, sort);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.getCategoryTerms: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$categoryGuid = categoryGuid_example; // String | unique identifier for glossary category
$limit = limit_example; // String | page size - by default there is no paging
$offset = offset_example; // String | offset for pagination purpose
$sort = sort_example; // String | ASC (default) or DESC

try {
    $result = $api_instance->getCategoryTerms($categoryGuid, $limit, $offset, $sort);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GlossaryRESTApi->getCategoryTerms: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::GlossaryRESTApi->new();
my $categoryGuid = categoryGuid_example; # String | unique identifier for glossary category
my $limit = limit_example; # String | page size - by default there is no paging
my $offset = offset_example; # String | offset for pagination purpose
my $sort = sort_example; # String | ASC (default) or DESC

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

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

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
categoryGuid = categoryGuid_example # String | unique identifier for glossary category
limit = limit_example # String | page size - by default there is no paging (optional) (default to -1)
offset = offset_example # String | offset for pagination purpose (optional) (default to 0)
sort = sort_example # String | ASC (default) or DESC (optional) (default to ASC)

try: 
    api_response = api_instance.get_category_terms(categoryGuid, limit=limit, offset=offset, sort=sort)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->getCategoryTerms: %s\n" % e)

Parameters

Path parameters

Name	Description
categoryGuid*	String unique identifier for glossary category Required

Query parameters

Name	Description
limit	String page size - by default there is no paging
offset	String offset for pagination purpose
sort	String ASC (default) or DESC

Responses

Status: 200 - List of terms for the given category or an empty list

Schema

Status: 404 - If glossary category guid in invalid

getDetailedGlossary

Get a specific Glossary

/v2/glossary/{glossaryGuid}/detailed

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/glossary/{glossaryGuid}/detailed"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String glossaryGuid = glossaryGuid_example; // String | unique glossary identifier
        try {
            AtlasGlossaryExtInfo result = apiInstance.getDetailedGlossary(glossaryGuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#getDetailedGlossary");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GlossaryRESTApi;

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String glossaryGuid = glossaryGuid_example; // String | unique glossary identifier
        try {
            AtlasGlossaryExtInfo result = apiInstance.getDetailedGlossary(glossaryGuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#getDetailedGlossary");
            e.printStackTrace();
        }
    }
}

String *glossaryGuid = glossaryGuid_example; // unique glossary identifier

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

[apiInstance getDetailedGlossaryWith:glossaryGuid
              completionHandler: ^(AtlasGlossaryExtInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.GlossaryRESTApi()
var glossaryGuid = glossaryGuid_example; // {{String}} unique glossary identifier

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var glossaryGuid = glossaryGuid_example;  // String | unique glossary identifier

            try
            {
                AtlasGlossaryExtInfo result = apiInstance.getDetailedGlossary(glossaryGuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.getDetailedGlossary: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$glossaryGuid = glossaryGuid_example; // String | unique glossary identifier

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::GlossaryRESTApi->new();
my $glossaryGuid = glossaryGuid_example; # String | unique glossary identifier

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

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

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
glossaryGuid = glossaryGuid_example # String | unique glossary identifier

try: 
    api_response = api_instance.get_detailed_glossary(glossaryGuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->getDetailedGlossary: %s\n" % e)

Parameters

Path parameters

Name	Description
glossaryGuid*	String unique glossary identifier Required

Responses

Status: 200 - If glossary exists for given GUID

Schema

Status: 404 - If glossary GUID is invalid

getEntitiesAssignedWithTerm

Get all entity headers assigned with the specified term

/v2/glossary/terms/{termGuid}/assignedEntities

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/glossary/terms/{termGuid}/assignedEntities?limit=&offset=&sort="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String termGuid = termGuid_example; // String | GUID of the term
        String limit = limit_example; // String | page size - by default there is no paging
        String offset = offset_example; // String | offset for pagination purpose
        String sort = sort_example; // String | ASC (default) or DESC
        try {
            array[AtlasRelatedObjectId] result = apiInstance.getEntitiesAssignedWithTerm(termGuid, limit, offset, sort);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#getEntitiesAssignedWithTerm");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GlossaryRESTApi;

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String termGuid = termGuid_example; // String | GUID of the term
        String limit = limit_example; // String | page size - by default there is no paging
        String offset = offset_example; // String | offset for pagination purpose
        String sort = sort_example; // String | ASC (default) or DESC
        try {
            array[AtlasRelatedObjectId] result = apiInstance.getEntitiesAssignedWithTerm(termGuid, limit, offset, sort);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#getEntitiesAssignedWithTerm");
            e.printStackTrace();
        }
    }
}

String *termGuid = termGuid_example; // GUID of the term
String *limit = limit_example; // page size - by default there is no paging (optional) (default to -1)
String *offset = offset_example; // offset for pagination purpose (optional) (default to 0)
String *sort = sort_example; // ASC (default) or DESC (optional) (default to ASC)

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

[apiInstance getEntitiesAssignedWithTermWith:termGuid
    limit:limit
    offset:offset
    sort:sort
              completionHandler: ^(array[AtlasRelatedObjectId] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.GlossaryRESTApi()
var termGuid = termGuid_example; // {{String}} GUID of the term
var opts = { 
  'limit': limit_example, // {{String}} page size - by default there is no paging
  'offset': offset_example, // {{String}} offset for pagination purpose
  'sort': sort_example // {{String}} ASC (default) or DESC
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getEntitiesAssignedWithTerm(termGuid, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var termGuid = termGuid_example;  // String | GUID of the term
            var limit = limit_example;  // String | page size - by default there is no paging (optional)  (default to -1)
            var offset = offset_example;  // String | offset for pagination purpose (optional)  (default to 0)
            var sort = sort_example;  // String | ASC (default) or DESC (optional)  (default to ASC)

            try
            {
                array[AtlasRelatedObjectId] result = apiInstance.getEntitiesAssignedWithTerm(termGuid, limit, offset, sort);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.getEntitiesAssignedWithTerm: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$termGuid = termGuid_example; // String | GUID of the term
$limit = limit_example; // String | page size - by default there is no paging
$offset = offset_example; // String | offset for pagination purpose
$sort = sort_example; // String | ASC (default) or DESC

try {
    $result = $api_instance->getEntitiesAssignedWithTerm($termGuid, $limit, $offset, $sort);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GlossaryRESTApi->getEntitiesAssignedWithTerm: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::GlossaryRESTApi->new();
my $termGuid = termGuid_example; # String | GUID of the term
my $limit = limit_example; # String | page size - by default there is no paging
my $offset = offset_example; # String | offset for pagination purpose
my $sort = sort_example; # String | ASC (default) or DESC

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

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

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
termGuid = termGuid_example # String | GUID of the term
limit = limit_example # String | page size - by default there is no paging (optional) (default to -1)
offset = offset_example # String | offset for pagination purpose (optional) (default to 0)
sort = sort_example # String | ASC (default) or DESC (optional) (default to ASC)

try: 
    api_response = api_instance.get_entities_assigned_with_term(termGuid, limit=limit, offset=offset, sort=sort)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->getEntitiesAssignedWithTerm: %s\n" % e)

Parameters

Path parameters

Name	Description
termGuid*	String GUID of the term Required

Query parameters

Name	Description
limit	String page size - by default there is no paging
offset	String offset for pagination purpose
sort	String ASC (default) or DESC

Responses

Status: 200 - List of entity headers (if any) for the given glossary or an empty list

Schema

Status: 404 - If glossary term guid in invalid

getGlossaries

Retrieve all glossaries registered with Atlas

/v2/glossary

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/glossary?limit=&offset=&sort="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String limit = limit_example; // String | page size - by default there is no paging
        String offset = offset_example; // String | offset for pagination purpose
        String sort = sort_example; // String | Sort order, ASC (default) or DESC
        try {
            array[AtlasGlossary] result = apiInstance.getGlossaries(limit, offset, sort);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#getGlossaries");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GlossaryRESTApi;

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String limit = limit_example; // String | page size - by default there is no paging
        String offset = offset_example; // String | offset for pagination purpose
        String sort = sort_example; // String | Sort order, ASC (default) or DESC
        try {
            array[AtlasGlossary] result = apiInstance.getGlossaries(limit, offset, sort);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#getGlossaries");
            e.printStackTrace();
        }
    }
}

String *limit = limit_example; // page size - by default there is no paging (optional) (default to -1)
String *offset = offset_example; // offset for pagination purpose (optional) (default to 0)
String *sort = sort_example; // Sort order, ASC (default) or DESC (optional) (default to ASC)

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

[apiInstance getGlossariesWith:limit
    offset:offset
    sort:sort
              completionHandler: ^(array[AtlasGlossary] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.GlossaryRESTApi()
var opts = { 
  'limit': limit_example, // {{String}} page size - by default there is no paging
  'offset': offset_example, // {{String}} offset for pagination purpose
  'sort': sort_example // {{String}} Sort order, ASC (default) or DESC
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getGlossaries(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var limit = limit_example;  // String | page size - by default there is no paging (optional)  (default to -1)
            var offset = offset_example;  // String | offset for pagination purpose (optional)  (default to 0)
            var sort = sort_example;  // String | Sort order, ASC (default) or DESC (optional)  (default to ASC)

            try
            {
                array[AtlasGlossary] result = apiInstance.getGlossaries(limit, offset, sort);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.getGlossaries: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$limit = limit_example; // String | page size - by default there is no paging
$offset = offset_example; // String | offset for pagination purpose
$sort = sort_example; // String | Sort order, ASC (default) or DESC

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::GlossaryRESTApi->new();
my $limit = limit_example; # String | page size - by default there is no paging
my $offset = offset_example; # String | offset for pagination purpose
my $sort = sort_example; # String | Sort order, ASC (default) or DESC

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

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

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
limit = limit_example # String | page size - by default there is no paging (optional) (default to -1)
offset = offset_example # String | offset for pagination purpose (optional) (default to 0)
sort = sort_example # String | Sort order, ASC (default) or DESC (optional) (default to ASC)

try: 
    api_response = api_instance.get_glossaries(limit=limit, offset=offset, sort=sort)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->getGlossaries: %s\n" % e)

Parameters

Query parameters

Name	Description
limit	String page size - by default there is no paging
offset	String offset for pagination purpose
sort	String Sort order, ASC (default) or DESC

Responses

Status: 200 - List of existing glossaries fitting the search criteria or empty list if nothing matches

Schema

getGlossary

Get a specific Glossary

/v2/glossary/{glossaryGuid}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/glossary/{glossaryGuid}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String glossaryGuid = glossaryGuid_example; // String | unique glossary identifier
        try {
            AtlasGlossary result = apiInstance.getGlossary(glossaryGuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#getGlossary");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GlossaryRESTApi;

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String glossaryGuid = glossaryGuid_example; // String | unique glossary identifier
        try {
            AtlasGlossary result = apiInstance.getGlossary(glossaryGuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#getGlossary");
            e.printStackTrace();
        }
    }
}

String *glossaryGuid = glossaryGuid_example; // unique glossary identifier

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

[apiInstance getGlossaryWith:glossaryGuid
              completionHandler: ^(AtlasGlossary output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.GlossaryRESTApi()
var glossaryGuid = glossaryGuid_example; // {{String}} unique glossary identifier

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var glossaryGuid = glossaryGuid_example;  // String | unique glossary identifier

            try
            {
                AtlasGlossary result = apiInstance.getGlossary(glossaryGuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.getGlossary: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$glossaryGuid = glossaryGuid_example; // String | unique glossary identifier

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::GlossaryRESTApi->new();
my $glossaryGuid = glossaryGuid_example; # String | unique glossary identifier

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

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

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
glossaryGuid = glossaryGuid_example # String | unique glossary identifier

try: 
    api_response = api_instance.get_glossary(glossaryGuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->getGlossary: %s\n" % e)

Parameters

Path parameters

Name	Description
glossaryGuid*	String unique glossary identifier Required

Responses

Status: 200 - If glossary with given guid exists

Schema

Status: 404 - If glossary GUID is invalid

getGlossaryCategories

Get the categories belonging to a specific glossary

/v2/glossary/{glossaryGuid}/categories

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/glossary/{glossaryGuid}/categories?limit=&offset=&sort="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String glossaryGuid = glossaryGuid_example; // String | unique identifier for glossary term
        String limit = limit_example; // String | page size - by default there is no paging
        String offset = offset_example; // String | offset for pagination purpose
        String sort = sort_example; // String | ASC (default) or DESC
        try {
            array[AtlasGlossaryCategory] result = apiInstance.getGlossaryCategories(glossaryGuid, limit, offset, sort);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#getGlossaryCategories");
            e.printStackTrace();
        }
    }
}

import io.swagger.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 term
        String limit = limit_example; // String | page size - by default there is no paging
        String offset = offset_example; // String | offset for pagination purpose
        String sort = sort_example; // String | ASC (default) or DESC
        try {
            array[AtlasGlossaryCategory] result = apiInstance.getGlossaryCategories(glossaryGuid, limit, offset, sort);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#getGlossaryCategories");
            e.printStackTrace();
        }
    }
}

String *glossaryGuid = glossaryGuid_example; // unique identifier for glossary term
String *limit = limit_example; // page size - by default there is no paging (optional) (default to -1)
String *offset = offset_example; // offset for pagination purpose (optional) (default to 0)
String *sort = sort_example; // ASC (default) or DESC (optional) (default to ASC)

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

[apiInstance getGlossaryCategoriesWith:glossaryGuid
    limit:limit
    offset:offset
    sort:sort
              completionHandler: ^(array[AtlasGlossaryCategory] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.GlossaryRESTApi()
var glossaryGuid = glossaryGuid_example; // {{String}} unique identifier for glossary term
var opts = { 
  'limit': limit_example, // {{String}} page size - by default there is no paging
  'offset': offset_example, // {{String}} offset for pagination purpose
  'sort': sort_example // {{String}} ASC (default) or DESC
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getGlossaryCategories(glossaryGuid, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var glossaryGuid = glossaryGuid_example;  // String | unique identifier for glossary term
            var limit = limit_example;  // String | page size - by default there is no paging (optional)  (default to -1)
            var offset = offset_example;  // String | offset for pagination purpose (optional)  (default to 0)
            var sort = sort_example;  // String | ASC (default) or DESC (optional)  (default to ASC)

            try
            {
                array[AtlasGlossaryCategory] result = apiInstance.getGlossaryCategories(glossaryGuid, limit, offset, sort);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.getGlossaryCategories: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$glossaryGuid = glossaryGuid_example; // String | unique identifier for glossary term
$limit = limit_example; // String | page size - by default there is no paging
$offset = offset_example; // String | offset for pagination purpose
$sort = sort_example; // String | ASC (default) or DESC

try {
    $result = $api_instance->getGlossaryCategories($glossaryGuid, $limit, $offset, $sort);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GlossaryRESTApi->getGlossaryCategories: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::GlossaryRESTApi->new();
my $glossaryGuid = glossaryGuid_example; # String | unique identifier for glossary term
my $limit = limit_example; # String | page size - by default there is no paging
my $offset = offset_example; # String | offset for pagination purpose
my $sort = sort_example; # String | ASC (default) or DESC

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

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

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
glossaryGuid = glossaryGuid_example # String | unique identifier for glossary term
limit = limit_example # String | page size - by default there is no paging (optional) (default to -1)
offset = offset_example # String | offset for pagination purpose (optional) (default to 0)
sort = sort_example # String | ASC (default) or DESC (optional) (default to ASC)

try: 
    api_response = api_instance.get_glossary_categories(glossaryGuid, limit=limit, offset=offset, sort=sort)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->getGlossaryCategories: %s\n" % e)

Parameters

Path parameters

Name	Description
glossaryGuid*	String unique identifier for glossary term Required

Query parameters

Name	Description
limit	String page size - by default there is no paging
offset	String offset for pagination purpose
sort	String ASC (default) or DESC

Responses

Status: 200 - List of glossary categories for the given glossary or an empty list

Schema

Status: 404 - If glossary guid in invalid

getGlossaryCategoriesHeaders

Get the categories belonging to a specific glossary

/v2/glossary/{glossaryGuid}/categories/headers

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/glossary/{glossaryGuid}/categories/headers?limit=&offset=&sort="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String glossaryGuid = glossaryGuid_example; // String | unique identifier for glossary term
        String limit = limit_example; // String | page size - by default there is no paging
        String offset = offset_example; // String | offset for pagination purpose
        String sort = sort_example; // String | ASC (default) or DESC
        try {
            array[AtlasRelatedCategoryHeader] result = apiInstance.getGlossaryCategoriesHeaders(glossaryGuid, limit, offset, sort);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#getGlossaryCategoriesHeaders");
            e.printStackTrace();
        }
    }
}

import io.swagger.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 term
        String limit = limit_example; // String | page size - by default there is no paging
        String offset = offset_example; // String | offset for pagination purpose
        String sort = sort_example; // String | ASC (default) or DESC
        try {
            array[AtlasRelatedCategoryHeader] result = apiInstance.getGlossaryCategoriesHeaders(glossaryGuid, limit, offset, sort);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#getGlossaryCategoriesHeaders");
            e.printStackTrace();
        }
    }
}

String *glossaryGuid = glossaryGuid_example; // unique identifier for glossary term
String *limit = limit_example; // page size - by default there is no paging (optional) (default to -1)
String *offset = offset_example; // offset for pagination purpose (optional) (default to 0)
String *sort = sort_example; // ASC (default) or DESC (optional) (default to ASC)

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

[apiInstance getGlossaryCategoriesHeadersWith:glossaryGuid
    limit:limit
    offset:offset
    sort:sort
              completionHandler: ^(array[AtlasRelatedCategoryHeader] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.GlossaryRESTApi()
var glossaryGuid = glossaryGuid_example; // {{String}} unique identifier for glossary term
var opts = { 
  'limit': limit_example, // {{String}} page size - by default there is no paging
  'offset': offset_example, // {{String}} offset for pagination purpose
  'sort': sort_example // {{String}} ASC (default) or DESC
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getGlossaryCategoriesHeaders(glossaryGuid, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var glossaryGuid = glossaryGuid_example;  // String | unique identifier for glossary term
            var limit = limit_example;  // String | page size - by default there is no paging (optional)  (default to -1)
            var offset = offset_example;  // String | offset for pagination purpose (optional)  (default to 0)
            var sort = sort_example;  // String | ASC (default) or DESC (optional)  (default to ASC)

            try
            {
                array[AtlasRelatedCategoryHeader] result = apiInstance.getGlossaryCategoriesHeaders(glossaryGuid, limit, offset, sort);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.getGlossaryCategoriesHeaders: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$glossaryGuid = glossaryGuid_example; // String | unique identifier for glossary term
$limit = limit_example; // String | page size - by default there is no paging
$offset = offset_example; // String | offset for pagination purpose
$sort = sort_example; // String | ASC (default) or DESC

try {
    $result = $api_instance->getGlossaryCategoriesHeaders($glossaryGuid, $limit, $offset, $sort);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GlossaryRESTApi->getGlossaryCategoriesHeaders: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::GlossaryRESTApi->new();
my $glossaryGuid = glossaryGuid_example; # String | unique identifier for glossary term
my $limit = limit_example; # String | page size - by default there is no paging
my $offset = offset_example; # String | offset for pagination purpose
my $sort = sort_example; # String | ASC (default) or DESC

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

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

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
glossaryGuid = glossaryGuid_example # String | unique identifier for glossary term
limit = limit_example # String | page size - by default there is no paging (optional) (default to -1)
offset = offset_example # String | offset for pagination purpose (optional) (default to 0)
sort = sort_example # String | ASC (default) or DESC (optional) (default to ASC)

try: 
    api_response = api_instance.get_glossary_categories_headers(glossaryGuid, limit=limit, offset=offset, sort=sort)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->getGlossaryCategoriesHeaders: %s\n" % e)

Parameters

Path parameters

Name	Description
glossaryGuid*	String unique identifier for glossary term Required

Query parameters

Name	Description
limit	String page size - by default there is no paging
offset	String offset for pagination purpose
sort	String ASC (default) or DESC

Responses

Status: 200 - List of glossary categories for the given glossary or an empty list

Schema

Status: 404 - If glossary guid in invalid

getGlossaryCategory

Get specific glossary category

/v2/glossary/category/{categoryGuid}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/glossary/category/{categoryGuid}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String categoryGuid = categoryGuid_example; // String | unique identifier for glossary category
        try {
            AtlasGlossaryCategory result = apiInstance.getGlossaryCategory(categoryGuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#getGlossaryCategory");
            e.printStackTrace();
        }
    }
}

import io.swagger.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 {
            AtlasGlossaryCategory result = apiInstance.getGlossaryCategory(categoryGuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#getGlossaryCategory");
            e.printStackTrace();
        }
    }
}

String *categoryGuid = categoryGuid_example; // unique identifier for glossary category

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

[apiInstance getGlossaryCategoryWith:categoryGuid
              completionHandler: ^(AtlasGlossaryCategory output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

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. Returned data: ' + data);
  }
};
api.getGlossaryCategory(categoryGuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var categoryGuid = categoryGuid_example;  // String | unique identifier for glossary category

            try
            {
                AtlasGlossaryCategory result = apiInstance.getGlossaryCategory(categoryGuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.getGlossaryCategory: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$categoryGuid = categoryGuid_example; // String | unique identifier for glossary category

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::GlossaryRESTApi->new();
my $categoryGuid = categoryGuid_example; # String | unique identifier for glossary category

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

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

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
categoryGuid = categoryGuid_example # String | unique identifier for glossary category

try: 
    api_response = api_instance.get_glossary_category(categoryGuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->getGlossaryCategory: %s\n" % e)

Parameters

Path parameters

Name	Description
categoryGuid*	String unique identifier for glossary category Required

Responses

Status: 200 - If glossary category exists for given GUID

Schema

Status: 404 - If glossary category GUID is invalid

getGlossaryTerm

Get specific glossary term

/v2/glossary/term/{termGuid}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/glossary/term/{termGuid}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String termGuid = termGuid_example; // String | unique identifier for glossary term
        try {
            AtlasGlossaryTerm result = apiInstance.getGlossaryTerm(termGuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#getGlossaryTerm");
            e.printStackTrace();
        }
    }
}

import io.swagger.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 {
            AtlasGlossaryTerm result = apiInstance.getGlossaryTerm(termGuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#getGlossaryTerm");
            e.printStackTrace();
        }
    }
}

String *termGuid = termGuid_example; // unique identifier for glossary term

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

[apiInstance getGlossaryTermWith:termGuid
              completionHandler: ^(AtlasGlossaryTerm output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

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. Returned data: ' + data);
  }
};
api.getGlossaryTerm(termGuid, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var termGuid = termGuid_example;  // String | unique identifier for glossary term

            try
            {
                AtlasGlossaryTerm result = apiInstance.getGlossaryTerm(termGuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.getGlossaryTerm: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$termGuid = termGuid_example; // String | unique identifier for glossary term

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::GlossaryRESTApi->new();
my $termGuid = termGuid_example; # String | unique identifier for glossary term

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

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

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
termGuid = termGuid_example # String | unique identifier for glossary term

try: 
    api_response = api_instance.get_glossary_term(termGuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->getGlossaryTerm: %s\n" % e)

Parameters

Path parameters

Name	Description
termGuid*	String unique identifier for glossary term Required

Responses

Status: 200 - If glossary term exists for given GUID

Schema

Status: 404 - If glossary term GUID is invalid

getGlossaryTermHeaders

Get term headers belonging to a specific glossary

/v2/glossary/{glossaryGuid}/terms/headers

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/glossary/{glossaryGuid}/terms/headers?limit=&offset=&sort="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String glossaryGuid = glossaryGuid_example; // String | unique identifier for glossary
        String limit = limit_example; // String | page size - by default there is no paging
        String offset = offset_example; // String | starting offset for loading terms
        String sort = sort_example; // String | ASC(default) or DESC
        try {
            array[AtlasRelatedTermHeader] result = apiInstance.getGlossaryTermHeaders(glossaryGuid, limit, offset, sort);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#getGlossaryTermHeaders");
            e.printStackTrace();
        }
    }
}

import io.swagger.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
        String limit = limit_example; // String | page size - by default there is no paging
        String offset = offset_example; // String | starting offset for loading terms
        String sort = sort_example; // String | ASC(default) or DESC
        try {
            array[AtlasRelatedTermHeader] result = apiInstance.getGlossaryTermHeaders(glossaryGuid, limit, offset, sort);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#getGlossaryTermHeaders");
            e.printStackTrace();
        }
    }
}

String *glossaryGuid = glossaryGuid_example; // unique identifier for glossary
String *limit = limit_example; // page size - by default there is no paging (optional) (default to -1)
String *offset = offset_example; // starting offset for loading terms (optional) (default to 0)
String *sort = sort_example; // ASC(default) or DESC (optional) (default to ASC)

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

[apiInstance getGlossaryTermHeadersWith:glossaryGuid
    limit:limit
    offset:offset
    sort:sort
              completionHandler: ^(array[AtlasRelatedTermHeader] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.GlossaryRESTApi()
var glossaryGuid = glossaryGuid_example; // {{String}} unique identifier for glossary
var opts = { 
  'limit': limit_example, // {{String}} page size - by default there is no paging
  'offset': offset_example, // {{String}} starting offset for loading terms
  'sort': sort_example // {{String}} ASC(default) or DESC
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getGlossaryTermHeaders(glossaryGuid, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var glossaryGuid = glossaryGuid_example;  // String | unique identifier for glossary
            var limit = limit_example;  // String | page size - by default there is no paging (optional)  (default to -1)
            var offset = offset_example;  // String | starting offset for loading terms (optional)  (default to 0)
            var sort = sort_example;  // String | ASC(default) or DESC (optional)  (default to ASC)

            try
            {
                array[AtlasRelatedTermHeader] result = apiInstance.getGlossaryTermHeaders(glossaryGuid, limit, offset, sort);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.getGlossaryTermHeaders: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$glossaryGuid = glossaryGuid_example; // String | unique identifier for glossary
$limit = limit_example; // String | page size - by default there is no paging
$offset = offset_example; // String | starting offset for loading terms
$sort = sort_example; // String | ASC(default) or DESC

try {
    $result = $api_instance->getGlossaryTermHeaders($glossaryGuid, $limit, $offset, $sort);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GlossaryRESTApi->getGlossaryTermHeaders: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::GlossaryRESTApi->new();
my $glossaryGuid = glossaryGuid_example; # String | unique identifier for glossary
my $limit = limit_example; # String | page size - by default there is no paging
my $offset = offset_example; # String | starting offset for loading terms
my $sort = sort_example; # String | ASC(default) or DESC

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

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

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
glossaryGuid = glossaryGuid_example # String | unique identifier for glossary
limit = limit_example # String | page size - by default there is no paging (optional) (default to -1)
offset = offset_example # String | starting offset for loading terms (optional) (default to 0)
sort = sort_example # String | ASC(default) or DESC (optional) (default to ASC)

try: 
    api_response = api_instance.get_glossary_term_headers(glossaryGuid, limit=limit, offset=offset, sort=sort)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->getGlossaryTermHeaders: %s\n" % e)

Parameters

Path parameters

Name	Description
glossaryGuid*	String unique identifier for glossary Required

Query parameters

Name	Description
limit	String page size - by default there is no paging
offset	String starting offset for loading terms
sort	String ASC(default) or DESC

Responses

Status: 200 - List of glossary terms for the given glossary or an empty list

Schema

Status: 404 - If glossary guid in invalid

getGlossaryTerms

Get terms belonging to a specific glossary

/v2/glossary/{glossaryGuid}/terms

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/glossary/{glossaryGuid}/terms?limit=&offset=&sort="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String glossaryGuid = glossaryGuid_example; // String | unique identifier for glossary
        String limit = limit_example; // String | page size - by default there is no paging
        String offset = offset_example; // String | starting offset for loading terms
        String sort = sort_example; // String | ASC(default) or DESC
        try {
            array[AtlasGlossaryTerm] result = apiInstance.getGlossaryTerms(glossaryGuid, limit, offset, sort);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#getGlossaryTerms");
            e.printStackTrace();
        }
    }
}

import io.swagger.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
        String limit = limit_example; // String | page size - by default there is no paging
        String offset = offset_example; // String | starting offset for loading terms
        String sort = sort_example; // String | ASC(default) or DESC
        try {
            array[AtlasGlossaryTerm] result = apiInstance.getGlossaryTerms(glossaryGuid, limit, offset, sort);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#getGlossaryTerms");
            e.printStackTrace();
        }
    }
}

String *glossaryGuid = glossaryGuid_example; // unique identifier for glossary
String *limit = limit_example; // page size - by default there is no paging (optional) (default to -1)
String *offset = offset_example; // starting offset for loading terms (optional) (default to 0)
String *sort = sort_example; // ASC(default) or DESC (optional) (default to ASC)

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

[apiInstance getGlossaryTermsWith:glossaryGuid
    limit:limit
    offset:offset
    sort:sort
              completionHandler: ^(array[AtlasGlossaryTerm] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.GlossaryRESTApi()
var glossaryGuid = glossaryGuid_example; // {{String}} unique identifier for glossary
var opts = { 
  'limit': limit_example, // {{String}} page size - by default there is no paging
  'offset': offset_example, // {{String}} starting offset for loading terms
  'sort': sort_example // {{String}} ASC(default) or DESC
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getGlossaryTerms(glossaryGuid, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var glossaryGuid = glossaryGuid_example;  // String | unique identifier for glossary
            var limit = limit_example;  // String | page size - by default there is no paging (optional)  (default to -1)
            var offset = offset_example;  // String | starting offset for loading terms (optional)  (default to 0)
            var sort = sort_example;  // String | ASC(default) or DESC (optional)  (default to ASC)

            try
            {
                array[AtlasGlossaryTerm] result = apiInstance.getGlossaryTerms(glossaryGuid, limit, offset, sort);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.getGlossaryTerms: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$glossaryGuid = glossaryGuid_example; // String | unique identifier for glossary
$limit = limit_example; // String | page size - by default there is no paging
$offset = offset_example; // String | starting offset for loading terms
$sort = sort_example; // String | ASC(default) or DESC

try {
    $result = $api_instance->getGlossaryTerms($glossaryGuid, $limit, $offset, $sort);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GlossaryRESTApi->getGlossaryTerms: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::GlossaryRESTApi->new();
my $glossaryGuid = glossaryGuid_example; # String | unique identifier for glossary
my $limit = limit_example; # String | page size - by default there is no paging
my $offset = offset_example; # String | starting offset for loading terms
my $sort = sort_example; # String | ASC(default) or DESC

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

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

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
glossaryGuid = glossaryGuid_example # String | unique identifier for glossary
limit = limit_example # String | page size - by default there is no paging (optional) (default to -1)
offset = offset_example # String | starting offset for loading terms (optional) (default to 0)
sort = sort_example # String | ASC(default) or DESC (optional) (default to ASC)

try: 
    api_response = api_instance.get_glossary_terms(glossaryGuid, limit=limit, offset=offset, sort=sort)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->getGlossaryTerms: %s\n" % e)

Parameters

Path parameters

Name	Description
glossaryGuid*	String unique identifier for glossary Required

Query parameters

Name	Description
limit	String page size - by default there is no paging
offset	String starting offset for loading terms
sort	String ASC(default) or DESC

Responses

Status: 200 - List of glossary terms for the given glossary or an empty list

Schema

Status: 404 - If glossary guid in invalid

getRelatedCategories

Get all related categories (parent and children)

/v2/glossary/category/{categoryGuid}/related

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/glossary/category/{categoryGuid}/related?limit=&offset=&sort="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String categoryGuid = categoryGuid_example; // String | unique identifier for glossary category
        String limit = limit_example; // String | page size - by default there is no paging
        String offset = offset_example; // String | offset for pagination purpose
        String sort = sort_example; // String | ASC (default) or DESC
        try {
            map['String', array[AtlasRelatedCategoryHeader]] result = apiInstance.getRelatedCategories(categoryGuid, limit, offset, sort);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#getRelatedCategories");
            e.printStackTrace();
        }
    }
}

import io.swagger.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
        String limit = limit_example; // String | page size - by default there is no paging
        String offset = offset_example; // String | offset for pagination purpose
        String sort = sort_example; // String | ASC (default) or DESC
        try {
            map['String', array[AtlasRelatedCategoryHeader]] result = apiInstance.getRelatedCategories(categoryGuid, limit, offset, sort);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#getRelatedCategories");
            e.printStackTrace();
        }
    }
}

String *categoryGuid = categoryGuid_example; // unique identifier for glossary category
String *limit = limit_example; // page size - by default there is no paging (optional) (default to -1)
String *offset = offset_example; // offset for pagination purpose (optional) (default to 0)
String *sort = sort_example; // ASC (default) or DESC (optional) (default to ASC)

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

[apiInstance getRelatedCategoriesWith:categoryGuid
    limit:limit
    offset:offset
    sort:sort
              completionHandler: ^(map['String', array[AtlasRelatedCategoryHeader]] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.GlossaryRESTApi()
var categoryGuid = categoryGuid_example; // {{String}} unique identifier for glossary category
var opts = { 
  'limit': limit_example, // {{String}} page size - by default there is no paging
  'offset': offset_example, // {{String}} offset for pagination purpose
  'sort': sort_example // {{String}} ASC (default) or DESC
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getRelatedCategories(categoryGuid, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var categoryGuid = categoryGuid_example;  // String | unique identifier for glossary category
            var limit = limit_example;  // String | page size - by default there is no paging (optional)  (default to -1)
            var offset = offset_example;  // String | offset for pagination purpose (optional)  (default to 0)
            var sort = sort_example;  // String | ASC (default) or DESC (optional)  (default to ASC)

            try
            {
                map['String', array[AtlasRelatedCategoryHeader]] result = apiInstance.getRelatedCategories(categoryGuid, limit, offset, sort);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.getRelatedCategories: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$categoryGuid = categoryGuid_example; // String | unique identifier for glossary category
$limit = limit_example; // String | page size - by default there is no paging
$offset = offset_example; // String | offset for pagination purpose
$sort = sort_example; // String | ASC (default) or DESC

try {
    $result = $api_instance->getRelatedCategories($categoryGuid, $limit, $offset, $sort);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GlossaryRESTApi->getRelatedCategories: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::GlossaryRESTApi->new();
my $categoryGuid = categoryGuid_example; # String | unique identifier for glossary category
my $limit = limit_example; # String | page size - by default there is no paging
my $offset = offset_example; # String | offset for pagination purpose
my $sort = sort_example; # String | ASC (default) or DESC

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

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

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
categoryGuid = categoryGuid_example # String | unique identifier for glossary category
limit = limit_example # String | page size - by default there is no paging (optional) (default to -1)
offset = offset_example # String | offset for pagination purpose (optional) (default to 0)
sort = sort_example # String | ASC (default) or DESC (optional) (default to ASC)

try: 
    api_response = api_instance.get_related_categories(categoryGuid, limit=limit, offset=offset, sort=sort)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->getRelatedCategories: %s\n" % e)

Parameters

Path parameters

Name	Description
categoryGuid*	String unique identifier for glossary category Required

Query parameters

Name	Description
limit	String page size - by default there is no paging
offset	String offset for pagination purpose
sort	String ASC (default) or DESC

Responses

Status: 200 - List of related categories

Schema

getRelatedTerms

Get all related terms for a specific term

/v2/glossary/terms/{termGuid}/related

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/glossary/terms/{termGuid}/related?limit=&offset=&sort="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String termGuid = termGuid_example; // String | unique identifier for glossary term
        String limit = limit_example; // String | page size - by default there is no paging
        String offset = offset_example; // String | offset for pagination purpose
        String sort = sort_example; // String | ASC (default) or DESC
        try {
            map['String', array[AtlasRelatedTermHeader]] result = apiInstance.getRelatedTerms(termGuid, limit, offset, sort);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#getRelatedTerms");
            e.printStackTrace();
        }
    }
}

import io.swagger.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
        String limit = limit_example; // String | page size - by default there is no paging
        String offset = offset_example; // String | offset for pagination purpose
        String sort = sort_example; // String | ASC (default) or DESC
        try {
            map['String', array[AtlasRelatedTermHeader]] result = apiInstance.getRelatedTerms(termGuid, limit, offset, sort);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#getRelatedTerms");
            e.printStackTrace();
        }
    }
}

String *termGuid = termGuid_example; // unique identifier for glossary term
String *limit = limit_example; // page size - by default there is no paging (optional) (default to -1)
String *offset = offset_example; // offset for pagination purpose (optional) (default to 0)
String *sort = sort_example; // ASC (default) or DESC (optional) (default to ASC)

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

[apiInstance getRelatedTermsWith:termGuid
    limit:limit
    offset:offset
    sort:sort
              completionHandler: ^(map['String', array[AtlasRelatedTermHeader]] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.GlossaryRESTApi()
var termGuid = termGuid_example; // {{String}} unique identifier for glossary term
var opts = { 
  'limit': limit_example, // {{String}} page size - by default there is no paging
  'offset': offset_example, // {{String}} offset for pagination purpose
  'sort': sort_example // {{String}} ASC (default) or DESC
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getRelatedTerms(termGuid, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var termGuid = termGuid_example;  // String | unique identifier for glossary term
            var limit = limit_example;  // String | page size - by default there is no paging (optional)  (default to -1)
            var offset = offset_example;  // String | offset for pagination purpose (optional)  (default to 0)
            var sort = sort_example;  // String | ASC (default) or DESC (optional)  (default to ASC)

            try
            {
                map['String', array[AtlasRelatedTermHeader]] result = apiInstance.getRelatedTerms(termGuid, limit, offset, sort);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.getRelatedTerms: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$termGuid = termGuid_example; // String | unique identifier for glossary term
$limit = limit_example; // String | page size - by default there is no paging
$offset = offset_example; // String | offset for pagination purpose
$sort = sort_example; // String | ASC (default) or DESC

try {
    $result = $api_instance->getRelatedTerms($termGuid, $limit, $offset, $sort);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GlossaryRESTApi->getRelatedTerms: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::GlossaryRESTApi->new();
my $termGuid = termGuid_example; # String | unique identifier for glossary term
my $limit = limit_example; # String | page size - by default there is no paging
my $offset = offset_example; # String | offset for pagination purpose
my $sort = sort_example; # String | ASC (default) or DESC

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

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

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
termGuid = termGuid_example # String | unique identifier for glossary term
limit = limit_example # String | page size - by default there is no paging (optional) (default to -1)
offset = offset_example # String | offset for pagination purpose (optional) (default to 0)
sort = sort_example # String | ASC (default) or DESC (optional) (default to ASC)

try: 
    api_response = api_instance.get_related_terms(termGuid, limit=limit, offset=offset, sort=sort)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->getRelatedTerms: %s\n" % e)

Parameters

Path parameters

Name	Description
termGuid*	String unique identifier for glossary term Required

Query parameters

Name	Description
limit	String page size - by default there is no paging
offset	String offset for pagination purpose
sort	String ASC (default) or DESC

Responses

Status: 200 - List of related glossary terms for the given glossary or an empty list

Schema

Status: 404 - If glossary term guid in invalid

importGlossaryData

Upload glossary file for creating AtlasGlossaryTerms in bulk

/v2/glossary/import

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: multipart/form-data"\
"/api/atlas//v2/glossary/import"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        byte[] fileDetail = fileDetail_example; // byte[] | 
        byte[] inputStream = inputStream_example; // byte[] | 
        try {
            BulkImportResponse result = apiInstance.importGlossaryData(fileDetail, inputStream);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#importGlossaryData");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GlossaryRESTApi;

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        byte[] fileDetail = fileDetail_example; // byte[] | 
        byte[] inputStream = inputStream_example; // byte[] | 
        try {
            BulkImportResponse result = apiInstance.importGlossaryData(fileDetail, inputStream);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#importGlossaryData");
            e.printStackTrace();
        }
    }
}

byte[] *fileDetail = fileDetail_example; //  (optional)
byte[] *inputStream = inputStream_example; //  (optional)

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

[apiInstance importGlossaryDataWith:fileDetail
    inputStream:inputStream
              completionHandler: ^(BulkImportResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.GlossaryRESTApi()
var opts = { 
  'fileDetail': fileDetail_example // {{byte[]}} 
  'inputStream': inputStream_example // {{byte[]}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.importGlossaryData(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var fileDetail = fileDetail_example;  // byte[] |  (optional) 
            var inputStream = inputStream_example;  // byte[] |  (optional) 

            try
            {
                BulkImportResponse result = apiInstance.importGlossaryData(fileDetail, inputStream);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.importGlossaryData: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$fileDetail = fileDetail_example; // byte[] | 
$inputStream = inputStream_example; // byte[] | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::GlossaryRESTApi->new();
my $fileDetail = fileDetail_example; # byte[] | 
my $inputStream = inputStream_example; # byte[] | 

eval { 
    my $result = $api_instance->importGlossaryData(fileDetail => $fileDetail, inputStream => $inputStream);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GlossaryRESTApi->importGlossaryData: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
fileDetail = fileDetail_example # byte[] |  (optional)
inputStream = inputStream_example # byte[] |  (optional)

try: 
    api_response = api_instance.import_glossary_data(fileDetail=fileDetail, inputStream=inputStream)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->importGlossaryData: %s\n" % e)

Parameters

Form parameters

Name	Description
fileDetail	byte[] (binary)
inputStream	byte[] (binary)

Responses

Status: 200 - If glossary term creation was successful

Schema

Status: 400 - If Glossary term definition has invalid or missing information

Status: 409 - If Glossary term already exists (duplicate qualifiedName)

partialUpdateGlossary

Partially update the glossary

/v2/glossary/{glossaryGuid}/partial

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/api/atlas//v2/glossary/{glossaryGuid}/partial"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String glossaryGuid = glossaryGuid_example; // String | unique identifier for glossary term
        map[String, String] body = ; // map[String, String] | Map containing keys as attribute names and values as corresponding attribute values
        try {
            AtlasGlossary result = apiInstance.partialUpdateGlossary(glossaryGuid, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#partialUpdateGlossary");
            e.printStackTrace();
        }
    }
}

import io.swagger.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 term
        map[String, String] body = ; // map[String, String] | Map containing keys as attribute names and values as corresponding attribute values
        try {
            AtlasGlossary result = apiInstance.partialUpdateGlossary(glossaryGuid, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#partialUpdateGlossary");
            e.printStackTrace();
        }
    }
}

String *glossaryGuid = glossaryGuid_example; // unique identifier for glossary term
map[String, String] *body = ; // Map containing keys as attribute names and values as corresponding attribute values (optional)

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

[apiInstance partialUpdateGlossaryWith:glossaryGuid
    body:body
              completionHandler: ^(AtlasGlossary output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.GlossaryRESTApi()
var glossaryGuid = glossaryGuid_example; // {{String}} unique identifier for glossary term
var opts = { 
  'body':  // {{map[String, String]}} Map containing keys as attribute names and values as corresponding attribute values
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.partialUpdateGlossary(glossaryGuid, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var glossaryGuid = glossaryGuid_example;  // String | unique identifier for glossary term
            var body = new map[String, String](); // map[String, String] | Map containing keys as attribute names and values as corresponding attribute values (optional) 

            try
            {
                AtlasGlossary result = apiInstance.partialUpdateGlossary(glossaryGuid, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.partialUpdateGlossary: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$glossaryGuid = glossaryGuid_example; // String | unique identifier for glossary term
$body = ; // map[String, String] | Map containing keys as attribute names and values as corresponding attribute values

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::GlossaryRESTApi->new();
my $glossaryGuid = glossaryGuid_example; # String | unique identifier for glossary term
my $body = WWW::SwaggerClient::Object::map[String, String]->new(); # map[String, String] | Map containing keys as attribute names and values as corresponding attribute values

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

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

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
glossaryGuid = glossaryGuid_example # String | unique identifier for glossary term
body =  # map[String, String] | Map containing keys as attribute names and values as corresponding attribute values (optional)

try: 
    api_response = api_instance.partial_update_glossary(glossaryGuid, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->partialUpdateGlossary: %s\n" % e)

Parameters

Path parameters

Name	Description
glossaryGuid*	String unique identifier for glossary term Required

Body parameters

Name	Description
body

Responses

Status: 200 - If glossary partial update was successful

Schema

Status: 400 - If partial update parameters are invalid

Status: 404 - If glossary guid in invalid

partialUpdateGlossaryCategory

Partially update the glossary category

/v2/glossary/category/{categoryGuid}/partial

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/api/atlas//v2/glossary/category/{categoryGuid}/partial"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String categoryGuid = categoryGuid_example; // String | unique identifier for glossary term
        map[String, String] body = ; // map[String, String] | Map containing keys as attribute names and values as corresponding attribute values
        try {
            AtlasGlossaryCategory result = apiInstance.partialUpdateGlossaryCategory(categoryGuid, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#partialUpdateGlossaryCategory");
            e.printStackTrace();
        }
    }
}

import io.swagger.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 term
        map[String, String] body = ; // map[String, String] | Map containing keys as attribute names and values as corresponding attribute values
        try {
            AtlasGlossaryCategory result = apiInstance.partialUpdateGlossaryCategory(categoryGuid, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#partialUpdateGlossaryCategory");
            e.printStackTrace();
        }
    }
}

String *categoryGuid = categoryGuid_example; // unique identifier for glossary term
map[String, String] *body = ; // Map containing keys as attribute names and values as corresponding attribute values (optional)

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

[apiInstance partialUpdateGlossaryCategoryWith:categoryGuid
    body:body
              completionHandler: ^(AtlasGlossaryCategory output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.GlossaryRESTApi()
var categoryGuid = categoryGuid_example; // {{String}} unique identifier for glossary term
var opts = { 
  'body':  // {{map[String, String]}} Map containing keys as attribute names and values as corresponding attribute values
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.partialUpdateGlossaryCategory(categoryGuid, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var categoryGuid = categoryGuid_example;  // String | unique identifier for glossary term
            var body = new map[String, String](); // map[String, String] | Map containing keys as attribute names and values as corresponding attribute values (optional) 

            try
            {
                AtlasGlossaryCategory result = apiInstance.partialUpdateGlossaryCategory(categoryGuid, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.partialUpdateGlossaryCategory: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$categoryGuid = categoryGuid_example; // String | unique identifier for glossary term
$body = ; // map[String, String] | Map containing keys as attribute names and values as corresponding attribute values

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::GlossaryRESTApi->new();
my $categoryGuid = categoryGuid_example; # String | unique identifier for glossary term
my $body = WWW::SwaggerClient::Object::map[String, String]->new(); # map[String, String] | Map containing keys as attribute names and values as corresponding attribute values

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

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

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
categoryGuid = categoryGuid_example # String | unique identifier for glossary term
body =  # map[String, String] | Map containing keys as attribute names and values as corresponding attribute values (optional)

try: 
    api_response = api_instance.partial_update_glossary_category(categoryGuid, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->partialUpdateGlossaryCategory: %s\n" % e)

Parameters

Path parameters

Name	Description
categoryGuid*	String unique identifier for glossary term Required

Body parameters

Name	Description
body

Responses

Status: 200 - If glossary category partial update was successful

Schema

Status: 400 - If category attributes are invalid

Status: 404 - If glossary category guid in invalid

partialUpdateGlossaryTerm

Partially update the glossary term

/v2/glossary/term/{termGuid}/partial

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/api/atlas//v2/glossary/term/{termGuid}/partial"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String termGuid = termGuid_example; // String | unique identifier for glossary term
        map[String, String] body = ; // map[String, String] | Map containing keys as attribute names and values as corresponding attribute values
        try {
            AtlasGlossaryTerm result = apiInstance.partialUpdateGlossaryTerm(termGuid, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#partialUpdateGlossaryTerm");
            e.printStackTrace();
        }
    }
}

import io.swagger.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
        map[String, String] body = ; // map[String, String] | Map containing keys as attribute names and values as corresponding attribute values
        try {
            AtlasGlossaryTerm result = apiInstance.partialUpdateGlossaryTerm(termGuid, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#partialUpdateGlossaryTerm");
            e.printStackTrace();
        }
    }
}

String *termGuid = termGuid_example; // unique identifier for glossary term
map[String, String] *body = ; // Map containing keys as attribute names and values as corresponding attribute values (optional)

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

[apiInstance partialUpdateGlossaryTermWith:termGuid
    body:body
              completionHandler: ^(AtlasGlossaryTerm output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.GlossaryRESTApi()
var termGuid = termGuid_example; // {{String}} unique identifier for glossary term
var opts = { 
  'body':  // {{map[String, String]}} Map containing keys as attribute names and values as corresponding attribute values
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.partialUpdateGlossaryTerm(termGuid, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var termGuid = termGuid_example;  // String | unique identifier for glossary term
            var body = new map[String, String](); // map[String, String] | Map containing keys as attribute names and values as corresponding attribute values (optional) 

            try
            {
                AtlasGlossaryTerm result = apiInstance.partialUpdateGlossaryTerm(termGuid, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.partialUpdateGlossaryTerm: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$termGuid = termGuid_example; // String | unique identifier for glossary term
$body = ; // map[String, String] | Map containing keys as attribute names and values as corresponding attribute values

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::GlossaryRESTApi->new();
my $termGuid = termGuid_example; # String | unique identifier for glossary term
my $body = WWW::SwaggerClient::Object::map[String, String]->new(); # map[String, String] | Map containing keys as attribute names and values as corresponding attribute values

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

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

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
termGuid = termGuid_example # String | unique identifier for glossary term
body =  # map[String, String] | Map containing keys as attribute names and values as corresponding attribute values (optional)

try: 
    api_response = api_instance.partial_update_glossary_term(termGuid, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->partialUpdateGlossaryTerm: %s\n" % e)

Parameters

Path parameters

Name	Description
termGuid*	String unique identifier for glossary term Required

Body parameters

Name	Description
body

Responses

Status: 200 - If glossary partial update was successful

Schema

Status: 400 - If partial attributes are invalid

Status: 404 - If glossary term guid in invalid

produceTemplate2

Get sample template for uploading/creating bulk AtlasGlossaryTerm

/v2/glossary/import/template

Usage and SDK Samples

curl -X GET\
-H "Accept: application/octet-stream"\
"/api/atlas//v2/glossary/import/template"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        try {
            byte[] result = apiInstance.produceTemplate2();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#produceTemplate2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GlossaryRESTApi;

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        try {
            byte[] result = apiInstance.produceTemplate2();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#produceTemplate2");
            e.printStackTrace();
        }
    }
}


GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();

            try
            {
                byte[] result = apiInstance.produceTemplate2();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.produceTemplate2: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::GlossaryRESTApi->new();

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

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

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()

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

Parameters

Responses

Status: 200 - Template File

Schema

Status: 400 - If the provided fileType is not supported

removeTermAssignmentFromEntities

Remove the term assignment for the given list of entity headers

/v2/glossary/terms/{termGuid}/assignedEntities

Usage and SDK Samples

curl -X DELETE\
-H "Content-Type: application/json"\
"/api/atlas//v2/glossary/terms/{termGuid}/assignedEntities"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String termGuid = termGuid_example; // String | Glossary term GUID
        array[AtlasRelatedObjectId] body = ; // array[AtlasRelatedObjectId] | List of related entity IDs from which the term has to be dissociated
        try {
            apiInstance.removeTermAssignmentFromEntities(termGuid, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#removeTermAssignmentFromEntities");
            e.printStackTrace();
        }
    }
}

import io.swagger.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] body = ; // array[AtlasRelatedObjectId] | List of related entity IDs from which the term has to be dissociated
        try {
            apiInstance.removeTermAssignmentFromEntities(termGuid, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#removeTermAssignmentFromEntities");
            e.printStackTrace();
        }
    }
}

String *termGuid = termGuid_example; // Glossary term GUID
array[AtlasRelatedObjectId] *body = ; // List of related entity IDs from which the term has to be dissociated (optional)

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.GlossaryRESTApi()
var termGuid = termGuid_example; // {{String}} Glossary term GUID
var opts = { 
  'body':  // {{array[AtlasRelatedObjectId]}} List of related entity IDs from which the term has to be dissociated
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.removeTermAssignmentFromEntities(termGuid, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var termGuid = termGuid_example;  // String | Glossary term GUID
            var body = new array[AtlasRelatedObjectId](); // array[AtlasRelatedObjectId] | List of related entity IDs from which the term has to be dissociated (optional) 

            try
            {
                apiInstance.removeTermAssignmentFromEntities(termGuid, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.removeTermAssignmentFromEntities: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$termGuid = termGuid_example; // String | Glossary term GUID
$body = ; // array[AtlasRelatedObjectId] | List of related entity IDs from which the term has to be dissociated

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::GlossaryRESTApi->new();
my $termGuid = termGuid_example; # String | Glossary term GUID
my $body = [WWW::SwaggerClient::Object::array[AtlasRelatedObjectId]->new()]; # array[AtlasRelatedObjectId] | List of related entity IDs from which the term has to be dissociated

eval { 
    $api_instance->removeTermAssignmentFromEntities(termGuid => $termGuid, body => $body);
};
if ($@) {
    warn "Exception when calling GlossaryRESTApi->removeTermAssignmentFromEntities: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
termGuid = termGuid_example # String | Glossary term GUID
body =  # array[AtlasRelatedObjectId] | List of related entity IDs from which the term has to be dissociated (optional)

try: 
    api_instance.remove_term_assignment_from_entities(termGuid, body=body)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->removeTermAssignmentFromEntities: %s\n" % e)

Parameters

Path parameters

Name	Description
termGuid*	String Glossary term GUID Required

Body parameters

Name	Description
body

Responses

Status: 204 - If glossary term dissociation was successful

Status: 400 - If ANY of the entity header is invalid

Status: 404 - If glossary term guid in invalid

updateGlossary

Update the given glossary

/v2/glossary/{glossaryGuid}

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/api/atlas//v2/glossary/{glossaryGuid}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String glossaryGuid = glossaryGuid_example; // String | unique identifier for glossary
        AtlasGlossary body = ; // AtlasGlossary | Updated glossary definition
        try {
            AtlasGlossary result = apiInstance.updateGlossary(glossaryGuid, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#updateGlossary");
            e.printStackTrace();
        }
    }
}

import io.swagger.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
        AtlasGlossary body = ; // AtlasGlossary | Updated glossary definition
        try {
            AtlasGlossary result = apiInstance.updateGlossary(glossaryGuid, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#updateGlossary");
            e.printStackTrace();
        }
    }
}

String *glossaryGuid = glossaryGuid_example; // unique identifier for glossary
AtlasGlossary *body = ; // Updated glossary definition (optional)

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

[apiInstance updateGlossaryWith:glossaryGuid
    body:body
              completionHandler: ^(AtlasGlossary output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.GlossaryRESTApi()
var glossaryGuid = glossaryGuid_example; // {{String}} unique identifier for glossary
var opts = { 
  'body':  // {{AtlasGlossary}} Updated glossary definition
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateGlossary(glossaryGuid, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var glossaryGuid = glossaryGuid_example;  // String | unique identifier for glossary
            var body = new AtlasGlossary(); // AtlasGlossary | Updated glossary definition (optional) 

            try
            {
                AtlasGlossary result = apiInstance.updateGlossary(glossaryGuid, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.updateGlossary: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$glossaryGuid = glossaryGuid_example; // String | unique identifier for glossary
$body = ; // AtlasGlossary | Updated glossary definition

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::GlossaryRESTApi->new();
my $glossaryGuid = glossaryGuid_example; # String | unique identifier for glossary
my $body = WWW::SwaggerClient::Object::AtlasGlossary->new(); # AtlasGlossary | Updated glossary definition

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

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

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
glossaryGuid = glossaryGuid_example # String | unique identifier for glossary
body =  # AtlasGlossary | Updated glossary definition (optional)

try: 
    api_response = api_instance.update_glossary(glossaryGuid, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->updateGlossary: %s\n" % e)

Parameters

Path parameters

Name	Description
glossaryGuid*	String unique identifier for glossary Required

Body parameters

Name	Description
body

Responses

Status: 200 - If glossary update was successful

Schema

Status: 400 - If Glossary definition has invalid or missing information

Status: 404 - If glossary guid in invalid

updateGlossaryCategory

Update the given glossary category

/v2/glossary/category/{categoryGuid}

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/api/atlas//v2/glossary/category/{categoryGuid}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String categoryGuid = categoryGuid_example; // String | unique identifier for glossary category
        AtlasGlossaryCategory body = ; // AtlasGlossaryCategory | updated glossary category
        try {
            AtlasGlossaryCategory result = apiInstance.updateGlossaryCategory(categoryGuid, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#updateGlossaryCategory");
            e.printStackTrace();
        }
    }
}

import io.swagger.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
        AtlasGlossaryCategory body = ; // AtlasGlossaryCategory | updated glossary category
        try {
            AtlasGlossaryCategory result = apiInstance.updateGlossaryCategory(categoryGuid, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#updateGlossaryCategory");
            e.printStackTrace();
        }
    }
}

String *categoryGuid = categoryGuid_example; // unique identifier for glossary category
AtlasGlossaryCategory *body = ; // updated glossary category (optional)

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

[apiInstance updateGlossaryCategoryWith:categoryGuid
    body:body
              completionHandler: ^(AtlasGlossaryCategory output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.GlossaryRESTApi()
var categoryGuid = categoryGuid_example; // {{String}} unique identifier for glossary category
var opts = { 
  'body':  // {{AtlasGlossaryCategory}} updated glossary category
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateGlossaryCategory(categoryGuid, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var categoryGuid = categoryGuid_example;  // String | unique identifier for glossary category
            var body = new AtlasGlossaryCategory(); // AtlasGlossaryCategory | updated glossary category (optional) 

            try
            {
                AtlasGlossaryCategory result = apiInstance.updateGlossaryCategory(categoryGuid, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.updateGlossaryCategory: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$categoryGuid = categoryGuid_example; // String | unique identifier for glossary category
$body = ; // AtlasGlossaryCategory | updated glossary category

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::GlossaryRESTApi->new();
my $categoryGuid = categoryGuid_example; # String | unique identifier for glossary category
my $body = WWW::SwaggerClient::Object::AtlasGlossaryCategory->new(); # AtlasGlossaryCategory | updated glossary category

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

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

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
categoryGuid = categoryGuid_example # String | unique identifier for glossary category
body =  # AtlasGlossaryCategory | updated glossary category (optional)

try: 
    api_response = api_instance.update_glossary_category(categoryGuid, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->updateGlossaryCategory: %s\n" % e)

Parameters

Path parameters

Name	Description
categoryGuid*	String unique identifier for glossary category Required

Body parameters

Name	Description
body

Responses

Status: 200 - If glossary category partial update was successful

Schema

Status: 400 - If Glossary category definition has invalid or missing information

Status: 404 - If glossary category guid in invalid

updateGlossaryTerm

Update the given glossary term

/v2/glossary/term/{termGuid}

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/api/atlas//v2/glossary/term/{termGuid}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.GlossaryRESTApi;

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

public class GlossaryRESTApiExample {

    public static void main(String[] args) {
        
        GlossaryRESTApi apiInstance = new GlossaryRESTApi();
        String termGuid = termGuid_example; // String | unique identifier for glossary term
        AtlasGlossaryTerm body = ; // AtlasGlossaryTerm | updated glossary term
        try {
            AtlasGlossaryTerm result = apiInstance.updateGlossaryTerm(termGuid, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#updateGlossaryTerm");
            e.printStackTrace();
        }
    }
}

import io.swagger.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
        AtlasGlossaryTerm body = ; // AtlasGlossaryTerm | updated glossary term
        try {
            AtlasGlossaryTerm result = apiInstance.updateGlossaryTerm(termGuid, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlossaryRESTApi#updateGlossaryTerm");
            e.printStackTrace();
        }
    }
}

String *termGuid = termGuid_example; // unique identifier for glossary term
AtlasGlossaryTerm *body = ; // updated glossary term (optional)

GlossaryRESTApi *apiInstance = [[GlossaryRESTApi alloc] init];

[apiInstance updateGlossaryTermWith:termGuid
    body:body
              completionHandler: ^(AtlasGlossaryTerm output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.GlossaryRESTApi()
var termGuid = termGuid_example; // {{String}} unique identifier for glossary term
var opts = { 
  'body':  // {{AtlasGlossaryTerm}} updated glossary term
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateGlossaryTerm(termGuid, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new GlossaryRESTApi();
            var termGuid = termGuid_example;  // String | unique identifier for glossary term
            var body = new AtlasGlossaryTerm(); // AtlasGlossaryTerm | updated glossary term (optional) 

            try
            {
                AtlasGlossaryTerm result = apiInstance.updateGlossaryTerm(termGuid, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlossaryRESTApi.updateGlossaryTerm: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiGlossaryRESTApi();
$termGuid = termGuid_example; // String | unique identifier for glossary term
$body = ; // AtlasGlossaryTerm | updated glossary term

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::GlossaryRESTApi;

my $api_instance = WWW::SwaggerClient::GlossaryRESTApi->new();
my $termGuid = termGuid_example; # String | unique identifier for glossary term
my $body = WWW::SwaggerClient::Object::AtlasGlossaryTerm->new(); # AtlasGlossaryTerm | updated glossary term

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

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

# create an instance of the API class
api_instance = swagger_client.GlossaryRESTApi()
termGuid = termGuid_example # String | unique identifier for glossary term
body =  # AtlasGlossaryTerm | updated glossary term (optional)

try: 
    api_response = api_instance.update_glossary_term(termGuid, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GlossaryRESTApi->updateGlossaryTerm: %s\n" % e)

Parameters

Path parameters

Name	Description
termGuid*	String unique identifier for glossary term Required

Body parameters

Name	Description
body

Responses

Status: 200 - If glossary term update was successful

Schema

Status: 400 - If Glossary temr definition has invalid or missing information

Status: 404 - If glossary term guid in invalid

IndexRecoveryREST

getIndexRecoveryData

/v2/indexrecovery

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/indexrecovery"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IndexRecoveryRESTApi;

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

public class IndexRecoveryRESTApiExample {

    public static void main(String[] args) {
        
        IndexRecoveryRESTApi apiInstance = new IndexRecoveryRESTApi();
        try {
            map['String', 'String'] result = apiInstance.getIndexRecoveryData();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling IndexRecoveryRESTApi#getIndexRecoveryData");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.IndexRecoveryRESTApi;

public class IndexRecoveryRESTApiExample {

    public static void main(String[] args) {
        IndexRecoveryRESTApi apiInstance = new IndexRecoveryRESTApi();
        try {
            map['String', 'String'] result = apiInstance.getIndexRecoveryData();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling IndexRecoveryRESTApi#getIndexRecoveryData");
            e.printStackTrace();
        }
    }
}


IndexRecoveryRESTApi *apiInstance = [[IndexRecoveryRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new IndexRecoveryRESTApi();

            try
            {
                map['String', 'String'] result = apiInstance.getIndexRecoveryData();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling IndexRecoveryRESTApi.getIndexRecoveryData: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiIndexRecoveryRESTApi();

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IndexRecoveryRESTApi;

my $api_instance = WWW::SwaggerClient::IndexRecoveryRESTApi->new();

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

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

# create an instance of the API class
api_instance = swagger_client.IndexRecoveryRESTApi()

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

Parameters

Responses

Status: 200 - If Index recovery data exists for the given entity

Schema

Status: 400 - Bad query parameters

startCustomIndexRecovery

/v2/indexrecovery/start

Usage and SDK Samples

curl -X POST\
"/api/atlas//v2/indexrecovery/start?startTime="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.IndexRecoveryRESTApi;

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

public class IndexRecoveryRESTApiExample {

    public static void main(String[] args) {
        
        IndexRecoveryRESTApi apiInstance = new IndexRecoveryRESTApi();
        String startTime = startTime_example; // String | 
        try {
            apiInstance.startCustomIndexRecovery(startTime);
        } catch (ApiException e) {
            System.err.println("Exception when calling IndexRecoveryRESTApi#startCustomIndexRecovery");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.IndexRecoveryRESTApi;

public class IndexRecoveryRESTApiExample {

    public static void main(String[] args) {
        IndexRecoveryRESTApi apiInstance = new IndexRecoveryRESTApi();
        String startTime = startTime_example; // String | 
        try {
            apiInstance.startCustomIndexRecovery(startTime);
        } catch (ApiException e) {
            System.err.println("Exception when calling IndexRecoveryRESTApi#startCustomIndexRecovery");
            e.printStackTrace();
        }
    }
}

String *startTime = startTime_example; //  (optional)

IndexRecoveryRESTApi *apiInstance = [[IndexRecoveryRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.IndexRecoveryRESTApi()
var opts = { 
  'startTime': startTime_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.startCustomIndexRecovery(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new IndexRecoveryRESTApi();
            var startTime = startTime_example;  // String |  (optional) 

            try
            {
                apiInstance.startCustomIndexRecovery(startTime);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling IndexRecoveryRESTApi.startCustomIndexRecovery: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiIndexRecoveryRESTApi();
$startTime = startTime_example; // String | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::IndexRecoveryRESTApi;

my $api_instance = WWW::SwaggerClient::IndexRecoveryRESTApi->new();
my $startTime = startTime_example; # String | 

eval { 
    $api_instance->startCustomIndexRecovery(startTime => $startTime);
};
if ($@) {
    warn "Exception when calling IndexRecoveryRESTApi->startCustomIndexRecovery: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.IndexRecoveryRESTApi()
startTime = startTime_example # String |  (optional)

try: 
    api_instance.start_custom_index_recovery(startTime=startTime)
except ApiException as e:
    print("Exception when calling IndexRecoveryRESTApi->startCustomIndexRecovery: %s\n" % e)

Parameters

Query parameters

Name	Description
startTime	String

Responses

Status: 201 - Success

LineageREST

getLineageByUniqueAttribute

Returns lineage info about entity. In addition to the typeName path parameter, attribute key-value pair(s) can be provided in the following format attr:<attrName>=<attrValue> NOTE: The attrName and attrValue should be unique across entities, eg. qualifiedName

/v2/lineage/uniqueAttribute/type/{typeName}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/lineage/uniqueAttribute/type/{typeName}?depth=&direction="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LineageRESTApi;

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

public class LineageRESTApiExample {

    public static void main(String[] args) {
        
        LineageRESTApi apiInstance = new LineageRESTApi();
        String typeName = typeName_example; // String | - typeName of entity
        Integer depth = 56; // Integer | - number of hops for lineage
        String direction = direction_example; // String | - input, output or both
        try {
            AtlasLineageInfo result = apiInstance.getLineageByUniqueAttribute(typeName, depth, direction);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LineageRESTApi#getLineageByUniqueAttribute");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.LineageRESTApi;

public class LineageRESTApiExample {

    public static void main(String[] args) {
        LineageRESTApi apiInstance = new LineageRESTApi();
        String typeName = typeName_example; // String | - typeName of entity
        Integer depth = 56; // Integer | - number of hops for lineage
        String direction = direction_example; // String | - input, output or both
        try {
            AtlasLineageInfo result = apiInstance.getLineageByUniqueAttribute(typeName, depth, direction);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LineageRESTApi#getLineageByUniqueAttribute");
            e.printStackTrace();
        }
    }
}

String *typeName = typeName_example; // - typeName of entity
Integer *depth = 56; // - number of hops for lineage (optional) (default to 3)
String *direction = direction_example; // - input, output or both (optional) (default to BOTH)

LineageRESTApi *apiInstance = [[LineageRESTApi alloc] init];

[apiInstance getLineageByUniqueAttributeWith:typeName
    depth:depth
    direction:direction
              completionHandler: ^(AtlasLineageInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.LineageRESTApi()
var typeName = typeName_example; // {{String}} - typeName of entity
var opts = { 
  'depth': 56, // {{Integer}} - number of hops for lineage
  'direction': direction_example // {{String}} - input, output or both
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getLineageByUniqueAttribute(typeName, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new LineageRESTApi();
            var typeName = typeName_example;  // String | - typeName of entity
            var depth = 56;  // Integer | - number of hops for lineage (optional)  (default to 3)
            var direction = direction_example;  // String | - input, output or both (optional)  (default to BOTH)

            try
            {
                AtlasLineageInfo result = apiInstance.getLineageByUniqueAttribute(typeName, depth, direction);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LineageRESTApi.getLineageByUniqueAttribute: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiLineageRESTApi();
$typeName = typeName_example; // String | - typeName of entity
$depth = 56; // Integer | - number of hops for lineage
$direction = direction_example; // String | - input, output or both

try {
    $result = $api_instance->getLineageByUniqueAttribute($typeName, $depth, $direction);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LineageRESTApi->getLineageByUniqueAttribute: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LineageRESTApi;

my $api_instance = WWW::SwaggerClient::LineageRESTApi->new();
my $typeName = typeName_example; # String | - typeName of entity
my $depth = 56; # Integer | - number of hops for lineage
my $direction = direction_example; # String | - input, output or both

eval { 
    my $result = $api_instance->getLineageByUniqueAttribute(typeName => $typeName, depth => $depth, direction => $direction);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LineageRESTApi->getLineageByUniqueAttribute: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.LineageRESTApi()
typeName = typeName_example # String | - typeName of entity
depth = 56 # Integer | - number of hops for lineage (optional) (default to 3)
direction = direction_example # String | - input, output or both (optional) (default to BOTH)

try: 
    api_response = api_instance.get_lineage_by_unique_attribute(typeName, depth=depth, direction=direction)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LineageRESTApi->getLineageByUniqueAttribute: %s\n" % e)

Parameters

Path parameters

Name	Description
typeName*	String - typeName of entity Required

Query parameters

Name	Description
depth	Integer (int32) - number of hops for lineage
direction	String - input, output or both

Responses

Status: 200 - If Lineage exists for the given entity

Schema

Status: 400 - Bad query parameters

Status: 404 - If no lineage is found for the given entity

getLineageGraph

Returns lineage info about entity.

/v2/lineage/{guid}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/lineage/{guid}?depth=&direction="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LineageRESTApi;

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

public class LineageRESTApiExample {

    public static void main(String[] args) {
        
        LineageRESTApi apiInstance = new LineageRESTApi();
        String guid = guid_example; // String | - unique entity id
        Integer depth = 56; // Integer | - number of hops for lineage
        String direction = direction_example; // String | - input, output or both
        try {
            AtlasLineageInfo result = apiInstance.getLineageGraph(guid, depth, direction);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LineageRESTApi#getLineageGraph");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.LineageRESTApi;

public class LineageRESTApiExample {

    public static void main(String[] args) {
        LineageRESTApi apiInstance = new LineageRESTApi();
        String guid = guid_example; // String | - unique entity id
        Integer depth = 56; // Integer | - number of hops for lineage
        String direction = direction_example; // String | - input, output or both
        try {
            AtlasLineageInfo result = apiInstance.getLineageGraph(guid, depth, direction);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LineageRESTApi#getLineageGraph");
            e.printStackTrace();
        }
    }
}

String *guid = guid_example; // - unique entity id
Integer *depth = 56; // - number of hops for lineage (optional) (default to 3)
String *direction = direction_example; // - input, output or both (optional) (default to BOTH)

LineageRESTApi *apiInstance = [[LineageRESTApi alloc] init];

[apiInstance getLineageGraphWith:guid
    depth:depth
    direction:direction
              completionHandler: ^(AtlasLineageInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.LineageRESTApi()
var guid = guid_example; // {{String}} - unique entity id
var opts = { 
  'depth': 56, // {{Integer}} - number of hops for lineage
  'direction': direction_example // {{String}} - input, output or both
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getLineageGraph(guid, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new LineageRESTApi();
            var guid = guid_example;  // String | - unique entity id
            var depth = 56;  // Integer | - number of hops for lineage (optional)  (default to 3)
            var direction = direction_example;  // String | - input, output or both (optional)  (default to BOTH)

            try
            {
                AtlasLineageInfo result = apiInstance.getLineageGraph(guid, depth, direction);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LineageRESTApi.getLineageGraph: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiLineageRESTApi();
$guid = guid_example; // String | - unique entity id
$depth = 56; // Integer | - number of hops for lineage
$direction = direction_example; // String | - input, output or both

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LineageRESTApi;

my $api_instance = WWW::SwaggerClient::LineageRESTApi->new();
my $guid = guid_example; # String | - unique entity id
my $depth = 56; # Integer | - number of hops for lineage
my $direction = direction_example; # String | - input, output or both

eval { 
    my $result = $api_instance->getLineageGraph(guid => $guid, depth => $depth, direction => $direction);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LineageRESTApi->getLineageGraph: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.LineageRESTApi()
guid = guid_example # String | - unique entity id
depth = 56 # Integer | - number of hops for lineage (optional) (default to 3)
direction = direction_example # String | - input, output or both (optional) (default to BOTH)

try: 
    api_response = api_instance.get_lineage_graph(guid, depth=depth, direction=direction)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LineageRESTApi->getLineageGraph: %s\n" % e)

Parameters

Path parameters

Name	Description
guid*	String - unique entity id Required

Query parameters

Name	Description
depth	Integer (int32) - number of hops for lineage
direction	String - input, output or both

Responses

Status: 200 - If Lineage exists for the given entity

Schema

Status: 400 - Bad query parameters

Status: 404 - If no lineage is found for the given entity

getLineageGraph2

Returns lineage info about entity.

/v2/lineage/{guid}

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/api/atlas//v2/lineage/{guid}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LineageRESTApi;

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

public class LineageRESTApiExample {

    public static void main(String[] args) {
        
        LineageRESTApi apiInstance = new LineageRESTApi();
        String guid = guid_example; // String | 
        map[String, LineageOnDemandConstraints] body = ; // map[String, LineageOnDemandConstraints] | 
        try {
            AtlasLineageInfo result = apiInstance.getLineageGraph2(guid, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LineageRESTApi#getLineageGraph2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.LineageRESTApi;

public class LineageRESTApiExample {

    public static void main(String[] args) {
        LineageRESTApi apiInstance = new LineageRESTApi();
        String guid = guid_example; // String | 
        map[String, LineageOnDemandConstraints] body = ; // map[String, LineageOnDemandConstraints] | 
        try {
            AtlasLineageInfo result = apiInstance.getLineageGraph2(guid, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LineageRESTApi#getLineageGraph2");
            e.printStackTrace();
        }
    }
}

String *guid = guid_example; // 
map[String, LineageOnDemandConstraints] *body = ; //  (optional)

LineageRESTApi *apiInstance = [[LineageRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.LineageRESTApi()
var guid = guid_example; // {{String}} 
var opts = { 
  'body':  // {{map[String, LineageOnDemandConstraints]}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getLineageGraph2(guid, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new LineageRESTApi();
            var guid = guid_example;  // String | 
            var body = new map[String, LineageOnDemandConstraints](); // map[String, LineageOnDemandConstraints] |  (optional) 

            try
            {
                AtlasLineageInfo result = apiInstance.getLineageGraph2(guid, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LineageRESTApi.getLineageGraph2: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiLineageRESTApi();
$guid = guid_example; // String | 
$body = ; // map[String, LineageOnDemandConstraints] | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LineageRESTApi;

my $api_instance = WWW::SwaggerClient::LineageRESTApi->new();
my $guid = guid_example; # String | 
my $body = WWW::SwaggerClient::Object::map[String, LineageOnDemandConstraints]->new(); # map[String, LineageOnDemandConstraints] | 

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

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

# create an instance of the API class
api_instance = swagger_client.LineageRESTApi()
guid = guid_example # String | 
body =  # map[String, LineageOnDemandConstraints] |  (optional)

try: 
    api_response = api_instance.get_lineage_graph2(guid, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LineageRESTApi->getLineageGraph2: %s\n" % e)

Parameters

Path parameters

Name	Description
guid*	String Required

Body parameters

Name	Description
body

Responses

Status: 200 - If Lineage exists for the given entity

Schema

Status: 400 - Bad query parameters

Status: 404 - If no lineage is found for the given entity

NotificationREST

handleNotifications

Publish notifications on Kafka topic

/v2/notification/topic/{topicName}

Usage and SDK Samples

curl -X POST\
"/api/atlas//v2/notification/topic/{topicName}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NotificationRESTApi;

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

public class NotificationRESTApiExample {

    public static void main(String[] args) {
        
        NotificationRESTApi apiInstance = new NotificationRESTApi();
        String topicName = topicName_example; // String | - nameOfTheQueue
        try {
            apiInstance.handleNotifications(topicName);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotificationRESTApi#handleNotifications");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.NotificationRESTApi;

public class NotificationRESTApiExample {

    public static void main(String[] args) {
        NotificationRESTApi apiInstance = new NotificationRESTApi();
        String topicName = topicName_example; // String | - nameOfTheQueue
        try {
            apiInstance.handleNotifications(topicName);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotificationRESTApi#handleNotifications");
            e.printStackTrace();
        }
    }
}

String *topicName = topicName_example; // - nameOfTheQueue

NotificationRESTApi *apiInstance = [[NotificationRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.NotificationRESTApi()
var topicName = topicName_example; // {{String}} - nameOfTheQueue

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new NotificationRESTApi();
            var topicName = topicName_example;  // String | - nameOfTheQueue

            try
            {
                apiInstance.handleNotifications(topicName);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NotificationRESTApi.handleNotifications: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiNotificationRESTApi();
$topicName = topicName_example; // String | - nameOfTheQueue

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NotificationRESTApi;

my $api_instance = WWW::SwaggerClient::NotificationRESTApi->new();
my $topicName = topicName_example; # String | - nameOfTheQueue

eval { 
    $api_instance->handleNotifications(topicName => $topicName);
};
if ($@) {
    warn "Exception when calling NotificationRESTApi->handleNotifications: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.NotificationRESTApi()
topicName = topicName_example # String | - nameOfTheQueue

try: 
    api_instance.handle_notifications(topicName)
except ApiException as e:
    print("Exception when calling NotificationRESTApi->handleNotifications: %s\n" % e)

Parameters

Path parameters

Name	Description
topicName*	String - nameOfTheQueue Required

Responses

Status: 201 - Success

RelationshipREST

create

Create a new relationship between entities.

/v2/relationship

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/api/atlas//v2/relationship"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.RelationshipRESTApi;

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

public class RelationshipRESTApiExample {

    public static void main(String[] args) {
        
        RelationshipRESTApi apiInstance = new RelationshipRESTApi();
        AtlasRelationship body = ; // AtlasRelationship | 
        try {
            AtlasRelationship result = apiInstance.create(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RelationshipRESTApi#create");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.RelationshipRESTApi;

public class RelationshipRESTApiExample {

    public static void main(String[] args) {
        RelationshipRESTApi apiInstance = new RelationshipRESTApi();
        AtlasRelationship body = ; // AtlasRelationship | 
        try {
            AtlasRelationship result = apiInstance.create(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RelationshipRESTApi#create");
            e.printStackTrace();
        }
    }
}

AtlasRelationship *body = ; //  (optional)

RelationshipRESTApi *apiInstance = [[RelationshipRESTApi alloc] init];

[apiInstance createWith:body
              completionHandler: ^(AtlasRelationship output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.RelationshipRESTApi()
var opts = { 
  'body':  // {{AtlasRelationship}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.create(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new RelationshipRESTApi();
            var body = new AtlasRelationship(); // AtlasRelationship |  (optional) 

            try
            {
                AtlasRelationship result = apiInstance.create(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RelationshipRESTApi.create: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiRelationshipRESTApi();
$body = ; // AtlasRelationship | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::RelationshipRESTApi;

my $api_instance = WWW::SwaggerClient::RelationshipRESTApi->new();
my $body = WWW::SwaggerClient::Object::AtlasRelationship->new(); # AtlasRelationship | 

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

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

# create an instance of the API class
api_instance = swagger_client.RelationshipRESTApi()
body =  # AtlasRelationship |  (optional)

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

Parameters

Body parameters

Name	Description
body

Responses

Status: 201 -

Schema

deleteById

Delete a relationship between entities using guid.

/v2/relationship/guid/{guid}

Usage and SDK Samples

curl -X DELETE\
"/api/atlas//v2/relationship/guid/{guid}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.RelationshipRESTApi;

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

public class RelationshipRESTApiExample {

    public static void main(String[] args) {
        
        RelationshipRESTApi apiInstance = new RelationshipRESTApi();
        String guid = guid_example; // String | 
        try {
            apiInstance.deleteById(guid);
        } catch (ApiException e) {
            System.err.println("Exception when calling RelationshipRESTApi#deleteById");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.RelationshipRESTApi;

public class RelationshipRESTApiExample {

    public static void main(String[] args) {
        RelationshipRESTApi apiInstance = new RelationshipRESTApi();
        String guid = guid_example; // String | 
        try {
            apiInstance.deleteById(guid);
        } catch (ApiException e) {
            System.err.println("Exception when calling RelationshipRESTApi#deleteById");
            e.printStackTrace();
        }
    }
}

String *guid = guid_example; // 

RelationshipRESTApi *apiInstance = [[RelationshipRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.RelationshipRESTApi()
var guid = guid_example; // {{String}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new RelationshipRESTApi();
            var guid = guid_example;  // String | 

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

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

$api_instance = new Swagger\Client\ApiRelationshipRESTApi();
$guid = guid_example; // String | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::RelationshipRESTApi;

my $api_instance = WWW::SwaggerClient::RelationshipRESTApi->new();
my $guid = guid_example; # String | 

eval { 
    $api_instance->deleteById(guid => $guid);
};
if ($@) {
    warn "Exception when calling RelationshipRESTApi->deleteById: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.RelationshipRESTApi()
guid = guid_example # String | 

try: 
    api_instance.delete_by_id(guid)
except ApiException as e:
    print("Exception when calling RelationshipRESTApi->deleteById: %s\n" % e)

Parameters

Path parameters

Name	Description
guid*	String Required

Responses

Status: 204 - Success

getById2

Get relationship information between entities using guid.

/v2/relationship/guid/{guid}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/relationship/guid/{guid}?extendedInfo="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.RelationshipRESTApi;

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

public class RelationshipRESTApiExample {

    public static void main(String[] args) {
        
        RelationshipRESTApi apiInstance = new RelationshipRESTApi();
        String guid = guid_example; // String | 
        Boolean extendedInfo = true; // Boolean | 
        try {
            AtlasRelationshipWithExtInfo result = apiInstance.getById2(guid, extendedInfo);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RelationshipRESTApi#getById2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.RelationshipRESTApi;

public class RelationshipRESTApiExample {

    public static void main(String[] args) {
        RelationshipRESTApi apiInstance = new RelationshipRESTApi();
        String guid = guid_example; // String | 
        Boolean extendedInfo = true; // Boolean | 
        try {
            AtlasRelationshipWithExtInfo result = apiInstance.getById2(guid, extendedInfo);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RelationshipRESTApi#getById2");
            e.printStackTrace();
        }
    }
}

String *guid = guid_example; // 
Boolean *extendedInfo = true; //  (optional) (default to false)

RelationshipRESTApi *apiInstance = [[RelationshipRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.RelationshipRESTApi()
var guid = guid_example; // {{String}} 
var opts = { 
  'extendedInfo': true // {{Boolean}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getById2(guid, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new RelationshipRESTApi();
            var guid = guid_example;  // String | 
            var extendedInfo = true;  // Boolean |  (optional)  (default to false)

            try
            {
                AtlasRelationshipWithExtInfo result = apiInstance.getById2(guid, extendedInfo);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RelationshipRESTApi.getById2: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiRelationshipRESTApi();
$guid = guid_example; // String | 
$extendedInfo = true; // Boolean | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::RelationshipRESTApi;

my $api_instance = WWW::SwaggerClient::RelationshipRESTApi->new();
my $guid = guid_example; # String | 
my $extendedInfo = true; # Boolean | 

eval { 
    my $result = $api_instance->getById2(guid => $guid, extendedInfo => $extendedInfo);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RelationshipRESTApi->getById2: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.RelationshipRESTApi()
guid = guid_example # String | 
extendedInfo = true # Boolean |  (optional) (default to false)

try: 
    api_response = api_instance.get_by_id2(guid, extendedInfo=extendedInfo)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RelationshipRESTApi->getById2: %s\n" % e)

Parameters

Path parameters

Name	Description
guid*	String Required

Query parameters

Name	Description
extendedInfo	Boolean

Responses

Status: 200 -

Schema

update

Update an existing relationship between entities.

/v2/relationship

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/api/atlas//v2/relationship"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.RelationshipRESTApi;

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

public class RelationshipRESTApiExample {

    public static void main(String[] args) {
        
        RelationshipRESTApi apiInstance = new RelationshipRESTApi();
        AtlasRelationship body = ; // AtlasRelationship | 
        try {
            AtlasRelationship result = apiInstance.update(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RelationshipRESTApi#update");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.RelationshipRESTApi;

public class RelationshipRESTApiExample {

    public static void main(String[] args) {
        RelationshipRESTApi apiInstance = new RelationshipRESTApi();
        AtlasRelationship body = ; // AtlasRelationship | 
        try {
            AtlasRelationship result = apiInstance.update(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RelationshipRESTApi#update");
            e.printStackTrace();
        }
    }
}

AtlasRelationship *body = ; //  (optional)

RelationshipRESTApi *apiInstance = [[RelationshipRESTApi alloc] init];

[apiInstance updateWith:body
              completionHandler: ^(AtlasRelationship output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.RelationshipRESTApi()
var opts = { 
  'body':  // {{AtlasRelationship}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.update(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new RelationshipRESTApi();
            var body = new AtlasRelationship(); // AtlasRelationship |  (optional) 

            try
            {
                AtlasRelationship result = apiInstance.update(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling RelationshipRESTApi.update: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiRelationshipRESTApi();
$body = ; // AtlasRelationship | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::RelationshipRESTApi;

my $api_instance = WWW::SwaggerClient::RelationshipRESTApi->new();
my $body = WWW::SwaggerClient::Object::AtlasRelationship->new(); # AtlasRelationship | 

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

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

# create an instance of the API class
api_instance = swagger_client.RelationshipRESTApi()
body =  # AtlasRelationship |  (optional)

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

Parameters

Body parameters

Name	Description
body

Responses

Status: 204 -

Schema

TypesREST

createAtlasTypeDefs

Bulk create APIs for all atlas type definitions, only new definitions will be created. Any changes to the existing definitions will be discarded

/v2/types/typedefs

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/api/atlas//v2/types/typedefs"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TypesRESTApi;

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

public class TypesRESTApiExample {

    public static void main(String[] args) {
        
        TypesRESTApi apiInstance = new TypesRESTApi();
        AtlasTypesDef body = ; // AtlasTypesDef | A composite wrapper object with corresponding lists of the type definition
        try {
            AtlasTypesDef result = apiInstance.createAtlasTypeDefs(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#createAtlasTypeDefs");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TypesRESTApi;

public class TypesRESTApiExample {

    public static void main(String[] args) {
        TypesRESTApi apiInstance = new TypesRESTApi();
        AtlasTypesDef body = ; // AtlasTypesDef | A composite wrapper object with corresponding lists of the type definition
        try {
            AtlasTypesDef result = apiInstance.createAtlasTypeDefs(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#createAtlasTypeDefs");
            e.printStackTrace();
        }
    }
}

AtlasTypesDef *body = ; // A composite wrapper object with corresponding lists of the type definition (optional)

TypesRESTApi *apiInstance = [[TypesRESTApi alloc] init];

[apiInstance createAtlasTypeDefsWith:body
              completionHandler: ^(AtlasTypesDef output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.TypesRESTApi()
var opts = { 
  'body':  // {{AtlasTypesDef}} A composite wrapper object with corresponding lists of the type definition
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createAtlasTypeDefs(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new TypesRESTApi();
            var body = new AtlasTypesDef(); // AtlasTypesDef | A composite wrapper object with corresponding lists of the type definition (optional) 

            try
            {
                AtlasTypesDef result = apiInstance.createAtlasTypeDefs(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TypesRESTApi.createAtlasTypeDefs: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiTypesRESTApi();
$body = ; // AtlasTypesDef | A composite wrapper object with corresponding lists of the type definition

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TypesRESTApi;

my $api_instance = WWW::SwaggerClient::TypesRESTApi->new();
my $body = WWW::SwaggerClient::Object::AtlasTypesDef->new(); # AtlasTypesDef | A composite wrapper object with corresponding lists of the type definition

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

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

# create an instance of the API class
api_instance = swagger_client.TypesRESTApi()
body =  # AtlasTypesDef | A composite wrapper object with corresponding lists of the type definition (optional)

try: 
    api_response = api_instance.create_atlas_type_defs(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TypesRESTApi->createAtlasTypeDefs: %s\n" % e)

Parameters

Body parameters

Name	Description
body

Responses

Status: 200 - On successful update of requested type definitions

Schema

Status: 400 - On validation failure for any type definitions

deleteAtlasTypeByName

Delete API for type identified by its name.

/v2/types/typedef/name/{typeName}

Usage and SDK Samples

curl -X DELETE\
"/api/atlas//v2/types/typedef/name/{typeName}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TypesRESTApi;

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

public class TypesRESTApiExample {

    public static void main(String[] args) {
        
        TypesRESTApi apiInstance = new TypesRESTApi();
        String typeName = typeName_example; // String | Name of the type to be deleted.
        try {
            apiInstance.deleteAtlasTypeByName(typeName);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#deleteAtlasTypeByName");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TypesRESTApi;

public class TypesRESTApiExample {

    public static void main(String[] args) {
        TypesRESTApi apiInstance = new TypesRESTApi();
        String typeName = typeName_example; // String | Name of the type to be deleted.
        try {
            apiInstance.deleteAtlasTypeByName(typeName);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#deleteAtlasTypeByName");
            e.printStackTrace();
        }
    }
}

String *typeName = typeName_example; // Name of the type to be deleted.

TypesRESTApi *apiInstance = [[TypesRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.TypesRESTApi()
var typeName = typeName_example; // {{String}} Name of the type to be deleted.

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new TypesRESTApi();
            var typeName = typeName_example;  // String | Name of the type to be deleted.

            try
            {
                apiInstance.deleteAtlasTypeByName(typeName);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TypesRESTApi.deleteAtlasTypeByName: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiTypesRESTApi();
$typeName = typeName_example; // String | Name of the type to be deleted.

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TypesRESTApi;

my $api_instance = WWW::SwaggerClient::TypesRESTApi->new();
my $typeName = typeName_example; # String | Name of the type to be deleted.

eval { 
    $api_instance->deleteAtlasTypeByName(typeName => $typeName);
};
if ($@) {
    warn "Exception when calling TypesRESTApi->deleteAtlasTypeByName: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.TypesRESTApi()
typeName = typeName_example # String | Name of the type to be deleted.

try: 
    api_instance.delete_atlas_type_by_name(typeName)
except ApiException as e:
    print("Exception when calling TypesRESTApi->deleteAtlasTypeByName: %s\n" % e)

Parameters

Path parameters

Name	Description
typeName*	String Name of the type to be deleted. Required

Responses

Status: 204 - On successful deletion of the requested type definitions

Status: 400 - On validation failure for any type definitions

deleteAtlasTypeDefs

Bulk delete API for all types

/v2/types/typedefs

Usage and SDK Samples

curl -X DELETE\
-H "Content-Type: application/json"\
"/api/atlas//v2/types/typedefs"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TypesRESTApi;

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

public class TypesRESTApiExample {

    public static void main(String[] args) {
        
        TypesRESTApi apiInstance = new TypesRESTApi();
        AtlasTypesDef body = ; // AtlasTypesDef | A composite object that captures all types to be deleted
        try {
            apiInstance.deleteAtlasTypeDefs(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#deleteAtlasTypeDefs");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TypesRESTApi;

public class TypesRESTApiExample {

    public static void main(String[] args) {
        TypesRESTApi apiInstance = new TypesRESTApi();
        AtlasTypesDef body = ; // AtlasTypesDef | A composite object that captures all types to be deleted
        try {
            apiInstance.deleteAtlasTypeDefs(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#deleteAtlasTypeDefs");
            e.printStackTrace();
        }
    }
}

AtlasTypesDef *body = ; // A composite object that captures all types to be deleted (optional)

TypesRESTApi *apiInstance = [[TypesRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.TypesRESTApi()
var opts = { 
  'body':  // {{AtlasTypesDef}} A composite object that captures all types to be deleted
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteAtlasTypeDefs(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new TypesRESTApi();
            var body = new AtlasTypesDef(); // AtlasTypesDef | A composite object that captures all types to be deleted (optional) 

            try
            {
                apiInstance.deleteAtlasTypeDefs(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TypesRESTApi.deleteAtlasTypeDefs: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiTypesRESTApi();
$body = ; // AtlasTypesDef | A composite object that captures all types to be deleted

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TypesRESTApi;

my $api_instance = WWW::SwaggerClient::TypesRESTApi->new();
my $body = WWW::SwaggerClient::Object::AtlasTypesDef->new(); # AtlasTypesDef | A composite object that captures all types to be deleted

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

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

# create an instance of the API class
api_instance = swagger_client.TypesRESTApi()
body =  # AtlasTypesDef | A composite object that captures all types to be deleted (optional)

try: 
    api_instance.delete_atlas_type_defs(body=body)
except ApiException as e:
    print("Exception when calling TypesRESTApi->deleteAtlasTypeDefs: %s\n" % e)

Parameters

Body parameters

Name	Description
body

Responses

Status: 204 - On successful deletion of the requested type definitions

Status: 400 - On validation failure for any type definitions

getAllTypeDefs

Bulk retrieval API for retrieving all type definitions in Atlas

/v2/types/typedefs

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/types/typedefs"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TypesRESTApi;

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

public class TypesRESTApiExample {

    public static void main(String[] args) {
        
        TypesRESTApi apiInstance = new TypesRESTApi();
        try {
            AtlasTypesDef result = apiInstance.getAllTypeDefs();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getAllTypeDefs");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TypesRESTApi;

public class TypesRESTApiExample {

    public static void main(String[] args) {
        TypesRESTApi apiInstance = new TypesRESTApi();
        try {
            AtlasTypesDef result = apiInstance.getAllTypeDefs();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getAllTypeDefs");
            e.printStackTrace();
        }
    }
}


TypesRESTApi *apiInstance = [[TypesRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new TypesRESTApi();

            try
            {
                AtlasTypesDef result = apiInstance.getAllTypeDefs();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TypesRESTApi.getAllTypeDefs: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiTypesRESTApi();

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TypesRESTApi;

my $api_instance = WWW::SwaggerClient::TypesRESTApi->new();

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

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

# create an instance of the API class
api_instance = swagger_client.TypesRESTApi()

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

Parameters

Responses

Status: 200 - AtlasTypesDef with type definitions matching the search criteria or else returns empty list of type definitions

Schema

getBusinessMetadataDefByGuid

Get the businessMetadata definition for the given guid

/v2/types/businessmetadatadef/guid/{guid}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/types/businessmetadatadef/guid/{guid}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TypesRESTApi;

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

public class TypesRESTApiExample {

    public static void main(String[] args) {
        
        TypesRESTApi apiInstance = new TypesRESTApi();
        String guid = guid_example; // String | businessMetadata guid
        try {
            AtlasBusinessMetadataDef result = apiInstance.getBusinessMetadataDefByGuid(guid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getBusinessMetadataDefByGuid");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TypesRESTApi;

public class TypesRESTApiExample {

    public static void main(String[] args) {
        TypesRESTApi apiInstance = new TypesRESTApi();
        String guid = guid_example; // String | businessMetadata guid
        try {
            AtlasBusinessMetadataDef result = apiInstance.getBusinessMetadataDefByGuid(guid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getBusinessMetadataDefByGuid");
            e.printStackTrace();
        }
    }
}

String *guid = guid_example; // businessMetadata guid

TypesRESTApi *apiInstance = [[TypesRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.TypesRESTApi()
var guid = guid_example; // {{String}} businessMetadata guid

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new TypesRESTApi();
            var guid = guid_example;  // String | businessMetadata guid

            try
            {
                AtlasBusinessMetadataDef result = apiInstance.getBusinessMetadataDefByGuid(guid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TypesRESTApi.getBusinessMetadataDefByGuid: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiTypesRESTApi();
$guid = guid_example; // String | businessMetadata guid

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TypesRESTApi;

my $api_instance = WWW::SwaggerClient::TypesRESTApi->new();
my $guid = guid_example; # String | businessMetadata guid

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

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

# create an instance of the API class
api_instance = swagger_client.TypesRESTApi()
guid = guid_example # String | businessMetadata guid

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

Parameters

Path parameters

Name	Description
guid*	String businessMetadata guid Required

Responses

Status: 200 - On successful lookup of the the businessMetadata definition by it's guid

Schema

Status: 404 - On Failed lookup for the given guid

getBusinessMetadataDefByName

Get the businessMetadata definition by it's name (unique)

/v2/types/businessmetadatadef/name/{name}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/types/businessmetadatadef/name/{name}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TypesRESTApi;

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

public class TypesRESTApiExample {

    public static void main(String[] args) {
        
        TypesRESTApi apiInstance = new TypesRESTApi();
        String name = name_example; // String | businessMetadata name
        try {
            AtlasBusinessMetadataDef result = apiInstance.getBusinessMetadataDefByName(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getBusinessMetadataDefByName");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TypesRESTApi;

public class TypesRESTApiExample {

    public static void main(String[] args) {
        TypesRESTApi apiInstance = new TypesRESTApi();
        String name = name_example; // String | businessMetadata name
        try {
            AtlasBusinessMetadataDef result = apiInstance.getBusinessMetadataDefByName(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getBusinessMetadataDefByName");
            e.printStackTrace();
        }
    }
}

String *name = name_example; // businessMetadata name

TypesRESTApi *apiInstance = [[TypesRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.TypesRESTApi()
var name = name_example; // {{String}} businessMetadata name

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new TypesRESTApi();
            var name = name_example;  // String | businessMetadata name

            try
            {
                AtlasBusinessMetadataDef result = apiInstance.getBusinessMetadataDefByName(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TypesRESTApi.getBusinessMetadataDefByName: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiTypesRESTApi();
$name = name_example; // String | businessMetadata name

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TypesRESTApi;

my $api_instance = WWW::SwaggerClient::TypesRESTApi->new();
my $name = name_example; # String | businessMetadata name

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

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

# create an instance of the API class
api_instance = swagger_client.TypesRESTApi()
name = name_example # String | businessMetadata name

try: 
    api_response = api_instance.get_business_metadata_def_by_name(name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TypesRESTApi->getBusinessMetadataDefByName: %s\n" % e)

Parameters

Path parameters

Name	Description
name*	String businessMetadata name Required

Responses

Status: 200 - On successful lookup of the the businessMetadata definition by it's name

Schema

Status: 404 - On Failed lookup for the given name

getClassificationDefByGuid

Get the classification definition for the given guid

/v2/types/classificationdef/guid/{guid}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/types/classificationdef/guid/{guid}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TypesRESTApi;

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

public class TypesRESTApiExample {

    public static void main(String[] args) {
        
        TypesRESTApi apiInstance = new TypesRESTApi();
        String guid = guid_example; // String | classification guid
        try {
            AtlasClassificationDef result = apiInstance.getClassificationDefByGuid(guid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getClassificationDefByGuid");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TypesRESTApi;

public class TypesRESTApiExample {

    public static void main(String[] args) {
        TypesRESTApi apiInstance = new TypesRESTApi();
        String guid = guid_example; // String | classification guid
        try {
            AtlasClassificationDef result = apiInstance.getClassificationDefByGuid(guid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getClassificationDefByGuid");
            e.printStackTrace();
        }
    }
}

String *guid = guid_example; // classification guid

TypesRESTApi *apiInstance = [[TypesRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.TypesRESTApi()
var guid = guid_example; // {{String}} classification guid

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new TypesRESTApi();
            var guid = guid_example;  // String | classification guid

            try
            {
                AtlasClassificationDef result = apiInstance.getClassificationDefByGuid(guid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TypesRESTApi.getClassificationDefByGuid: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiTypesRESTApi();
$guid = guid_example; // String | classification guid

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TypesRESTApi;

my $api_instance = WWW::SwaggerClient::TypesRESTApi->new();
my $guid = guid_example; # String | classification guid

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

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

# create an instance of the API class
api_instance = swagger_client.TypesRESTApi()
guid = guid_example # String | classification guid

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

Parameters

Path parameters

Name	Description
guid*	String classification guid Required

Responses

Status: 200 - On successful lookup of the the classification definition by it's guid

Schema

Status: 404 - On Failed lookup for the given guid

getClassificationDefByName

Get the classification definition by it's name (unique)

/v2/types/classificationdef/name/{name}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/types/classificationdef/name/{name}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TypesRESTApi;

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

public class TypesRESTApiExample {

    public static void main(String[] args) {
        
        TypesRESTApi apiInstance = new TypesRESTApi();
        String name = name_example; // String | classification name
        try {
            AtlasClassificationDef result = apiInstance.getClassificationDefByName(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getClassificationDefByName");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TypesRESTApi;

public class TypesRESTApiExample {

    public static void main(String[] args) {
        TypesRESTApi apiInstance = new TypesRESTApi();
        String name = name_example; // String | classification name
        try {
            AtlasClassificationDef result = apiInstance.getClassificationDefByName(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getClassificationDefByName");
            e.printStackTrace();
        }
    }
}

String *name = name_example; // classification name

TypesRESTApi *apiInstance = [[TypesRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.TypesRESTApi()
var name = name_example; // {{String}} classification name

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new TypesRESTApi();
            var name = name_example;  // String | classification name

            try
            {
                AtlasClassificationDef result = apiInstance.getClassificationDefByName(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TypesRESTApi.getClassificationDefByName: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiTypesRESTApi();
$name = name_example; // String | classification name

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TypesRESTApi;

my $api_instance = WWW::SwaggerClient::TypesRESTApi->new();
my $name = name_example; # String | classification name

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

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

# create an instance of the API class
api_instance = swagger_client.TypesRESTApi()
name = name_example # String | classification name

try: 
    api_response = api_instance.get_classification_def_by_name(name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TypesRESTApi->getClassificationDefByName: %s\n" % e)

Parameters

Path parameters

Name	Description
name*	String classification name Required

Responses

Status: 200 - On successful lookup of the the classification definition by it's name

Schema

Status: 404 - On Failed lookup for the given name

getEntityDefByGuid

Get the Entity definition for the given guid

/v2/types/entitydef/guid/{guid}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/types/entitydef/guid/{guid}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TypesRESTApi;

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

public class TypesRESTApiExample {

    public static void main(String[] args) {
        
        TypesRESTApi apiInstance = new TypesRESTApi();
        String guid = guid_example; // String | entity guid
        try {
            AtlasEntityDef result = apiInstance.getEntityDefByGuid(guid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getEntityDefByGuid");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TypesRESTApi;

public class TypesRESTApiExample {

    public static void main(String[] args) {
        TypesRESTApi apiInstance = new TypesRESTApi();
        String guid = guid_example; // String | entity guid
        try {
            AtlasEntityDef result = apiInstance.getEntityDefByGuid(guid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getEntityDefByGuid");
            e.printStackTrace();
        }
    }
}

String *guid = guid_example; // entity guid

TypesRESTApi *apiInstance = [[TypesRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.TypesRESTApi()
var guid = guid_example; // {{String}} entity guid

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new TypesRESTApi();
            var guid = guid_example;  // String | entity guid

            try
            {
                AtlasEntityDef result = apiInstance.getEntityDefByGuid(guid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TypesRESTApi.getEntityDefByGuid: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiTypesRESTApi();
$guid = guid_example; // String | entity guid

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TypesRESTApi;

my $api_instance = WWW::SwaggerClient::TypesRESTApi->new();
my $guid = guid_example; # String | entity guid

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

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

# create an instance of the API class
api_instance = swagger_client.TypesRESTApi()
guid = guid_example # String | entity guid

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

Parameters

Path parameters

Name	Description
guid*	String entity guid Required

Responses

Status: 200 - On successful lookup of the the entity definition by it's guid

Schema

Status: 404 - On Failed lookup for the given guid

getEntityDefByName

Get the entity definition by it's name (unique)

/v2/types/entitydef/name/{name}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/types/entitydef/name/{name}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TypesRESTApi;

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

public class TypesRESTApiExample {

    public static void main(String[] args) {
        
        TypesRESTApi apiInstance = new TypesRESTApi();
        String name = name_example; // String | entity name
        try {
            AtlasEntityDef result = apiInstance.getEntityDefByName(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getEntityDefByName");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TypesRESTApi;

public class TypesRESTApiExample {

    public static void main(String[] args) {
        TypesRESTApi apiInstance = new TypesRESTApi();
        String name = name_example; // String | entity name
        try {
            AtlasEntityDef result = apiInstance.getEntityDefByName(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getEntityDefByName");
            e.printStackTrace();
        }
    }
}

String *name = name_example; // entity name

TypesRESTApi *apiInstance = [[TypesRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.TypesRESTApi()
var name = name_example; // {{String}} entity name

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new TypesRESTApi();
            var name = name_example;  // String | entity name

            try
            {
                AtlasEntityDef result = apiInstance.getEntityDefByName(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TypesRESTApi.getEntityDefByName: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiTypesRESTApi();
$name = name_example; // String | entity name

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TypesRESTApi;

my $api_instance = WWW::SwaggerClient::TypesRESTApi->new();
my $name = name_example; # String | entity name

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

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

# create an instance of the API class
api_instance = swagger_client.TypesRESTApi()
name = name_example # String | entity name

try: 
    api_response = api_instance.get_entity_def_by_name(name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TypesRESTApi->getEntityDefByName: %s\n" % e)

Parameters

Path parameters

Name	Description
name*	String entity name Required

Responses

Status: 200 - On successful lookup of the the entity definition by it's name

Schema

Status: 404 - On Failed lookup for the given name

getEnumDefByGuid

Get the enum definition for the given guid

/v2/types/enumdef/guid/{guid}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/types/enumdef/guid/{guid}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TypesRESTApi;

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

public class TypesRESTApiExample {

    public static void main(String[] args) {
        
        TypesRESTApi apiInstance = new TypesRESTApi();
        String guid = guid_example; // String | enum guid
        try {
            AtlasEnumDef result = apiInstance.getEnumDefByGuid(guid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getEnumDefByGuid");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TypesRESTApi;

public class TypesRESTApiExample {

    public static void main(String[] args) {
        TypesRESTApi apiInstance = new TypesRESTApi();
        String guid = guid_example; // String | enum guid
        try {
            AtlasEnumDef result = apiInstance.getEnumDefByGuid(guid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getEnumDefByGuid");
            e.printStackTrace();
        }
    }
}

String *guid = guid_example; // enum guid

TypesRESTApi *apiInstance = [[TypesRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.TypesRESTApi()
var guid = guid_example; // {{String}} enum guid

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new TypesRESTApi();
            var guid = guid_example;  // String | enum guid

            try
            {
                AtlasEnumDef result = apiInstance.getEnumDefByGuid(guid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TypesRESTApi.getEnumDefByGuid: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiTypesRESTApi();
$guid = guid_example; // String | enum guid

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TypesRESTApi;

my $api_instance = WWW::SwaggerClient::TypesRESTApi->new();
my $guid = guid_example; # String | enum guid

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

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

# create an instance of the API class
api_instance = swagger_client.TypesRESTApi()
guid = guid_example # String | enum guid

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

Parameters

Path parameters

Name	Description
guid*	String enum guid Required

Responses

Status: 200 - On successful lookup of the the enum definition by it's guid

Schema

Status: 404 - On Failed lookup for the given guid

getEnumDefByName

Get the enum definition by it's name (unique)

/v2/types/enumdef/name/{name}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/types/enumdef/name/{name}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TypesRESTApi;

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

public class TypesRESTApiExample {

    public static void main(String[] args) {
        
        TypesRESTApi apiInstance = new TypesRESTApi();
        String name = name_example; // String | enum name
        try {
            AtlasEnumDef result = apiInstance.getEnumDefByName(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getEnumDefByName");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TypesRESTApi;

public class TypesRESTApiExample {

    public static void main(String[] args) {
        TypesRESTApi apiInstance = new TypesRESTApi();
        String name = name_example; // String | enum name
        try {
            AtlasEnumDef result = apiInstance.getEnumDefByName(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getEnumDefByName");
            e.printStackTrace();
        }
    }
}

String *name = name_example; // enum name

TypesRESTApi *apiInstance = [[TypesRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.TypesRESTApi()
var name = name_example; // {{String}} enum name

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new TypesRESTApi();
            var name = name_example;  // String | enum name

            try
            {
                AtlasEnumDef result = apiInstance.getEnumDefByName(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TypesRESTApi.getEnumDefByName: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiTypesRESTApi();
$name = name_example; // String | enum name

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TypesRESTApi;

my $api_instance = WWW::SwaggerClient::TypesRESTApi->new();
my $name = name_example; # String | enum name

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

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

# create an instance of the API class
api_instance = swagger_client.TypesRESTApi()
name = name_example # String | enum name

try: 
    api_response = api_instance.get_enum_def_by_name(name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TypesRESTApi->getEnumDefByName: %s\n" % e)

Parameters

Path parameters

Name	Description
name*	String enum name Required

Responses

Status: 200 - On successful lookup of the the enum definition by it's name

Schema

Status: 404 - On Failed lookup for the given name

getRelationshipDefByGuid

Get the relationship definition for the given guid

/v2/types/relationshipdef/guid/{guid}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/types/relationshipdef/guid/{guid}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TypesRESTApi;

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

public class TypesRESTApiExample {

    public static void main(String[] args) {
        
        TypesRESTApi apiInstance = new TypesRESTApi();
        String guid = guid_example; // String | relationship guid
        try {
            AtlasRelationshipDef result = apiInstance.getRelationshipDefByGuid(guid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getRelationshipDefByGuid");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TypesRESTApi;

public class TypesRESTApiExample {

    public static void main(String[] args) {
        TypesRESTApi apiInstance = new TypesRESTApi();
        String guid = guid_example; // String | relationship guid
        try {
            AtlasRelationshipDef result = apiInstance.getRelationshipDefByGuid(guid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getRelationshipDefByGuid");
            e.printStackTrace();
        }
    }
}

String *guid = guid_example; // relationship guid

TypesRESTApi *apiInstance = [[TypesRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.TypesRESTApi()
var guid = guid_example; // {{String}} relationship guid

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new TypesRESTApi();
            var guid = guid_example;  // String | relationship guid

            try
            {
                AtlasRelationshipDef result = apiInstance.getRelationshipDefByGuid(guid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TypesRESTApi.getRelationshipDefByGuid: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiTypesRESTApi();
$guid = guid_example; // String | relationship guid

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TypesRESTApi;

my $api_instance = WWW::SwaggerClient::TypesRESTApi->new();
my $guid = guid_example; # String | relationship guid

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

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

# create an instance of the API class
api_instance = swagger_client.TypesRESTApi()
guid = guid_example # String | relationship guid

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

Parameters

Path parameters

Name	Description
guid*	String relationship guid Required

Responses

Status: 200 - On successful lookup of the the relationship definition by it's guid

Schema

Status: 404 - On Failed lookup for the given guid

getRelationshipDefByName

Get the relationship definition by it's name (unique)

/v2/types/relationshipdef/name/{name}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/types/relationshipdef/name/{name}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TypesRESTApi;

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

public class TypesRESTApiExample {

    public static void main(String[] args) {
        
        TypesRESTApi apiInstance = new TypesRESTApi();
        String name = name_example; // String | relationship name
        try {
            AtlasRelationshipDef result = apiInstance.getRelationshipDefByName(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getRelationshipDefByName");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TypesRESTApi;

public class TypesRESTApiExample {

    public static void main(String[] args) {
        TypesRESTApi apiInstance = new TypesRESTApi();
        String name = name_example; // String | relationship name
        try {
            AtlasRelationshipDef result = apiInstance.getRelationshipDefByName(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getRelationshipDefByName");
            e.printStackTrace();
        }
    }
}

String *name = name_example; // relationship name

TypesRESTApi *apiInstance = [[TypesRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.TypesRESTApi()
var name = name_example; // {{String}} relationship name

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new TypesRESTApi();
            var name = name_example;  // String | relationship name

            try
            {
                AtlasRelationshipDef result = apiInstance.getRelationshipDefByName(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TypesRESTApi.getRelationshipDefByName: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiTypesRESTApi();
$name = name_example; // String | relationship name

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TypesRESTApi;

my $api_instance = WWW::SwaggerClient::TypesRESTApi->new();
my $name = name_example; # String | relationship name

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

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

# create an instance of the API class
api_instance = swagger_client.TypesRESTApi()
name = name_example # String | relationship name

try: 
    api_response = api_instance.get_relationship_def_by_name(name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TypesRESTApi->getRelationshipDefByName: %s\n" % e)

Parameters

Path parameters

Name	Description
name*	String relationship name Required

Responses

Status: 200 - On successful lookup of the the relationship definition by it's name

Schema

Status: 404 - On Failed lookup for the given name

getStructDefByGuid

Get the struct definition for the given guid

/v2/types/structdef/guid/{guid}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/types/structdef/guid/{guid}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TypesRESTApi;

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

public class TypesRESTApiExample {

    public static void main(String[] args) {
        
        TypesRESTApi apiInstance = new TypesRESTApi();
        String guid = guid_example; // String | struct guid
        try {
            AtlasStructDef result = apiInstance.getStructDefByGuid(guid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getStructDefByGuid");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TypesRESTApi;

public class TypesRESTApiExample {

    public static void main(String[] args) {
        TypesRESTApi apiInstance = new TypesRESTApi();
        String guid = guid_example; // String | struct guid
        try {
            AtlasStructDef result = apiInstance.getStructDefByGuid(guid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getStructDefByGuid");
            e.printStackTrace();
        }
    }
}

String *guid = guid_example; // struct guid

TypesRESTApi *apiInstance = [[TypesRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.TypesRESTApi()
var guid = guid_example; // {{String}} struct guid

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new TypesRESTApi();
            var guid = guid_example;  // String | struct guid

            try
            {
                AtlasStructDef result = apiInstance.getStructDefByGuid(guid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TypesRESTApi.getStructDefByGuid: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiTypesRESTApi();
$guid = guid_example; // String | struct guid

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TypesRESTApi;

my $api_instance = WWW::SwaggerClient::TypesRESTApi->new();
my $guid = guid_example; # String | struct guid

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

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

# create an instance of the API class
api_instance = swagger_client.TypesRESTApi()
guid = guid_example # String | struct guid

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

Parameters

Path parameters

Name	Description
guid*	String struct guid Required

Responses

Status: 200 - On successful lookup of the the struct definition by it's guid

Schema

Status: 404 - On Failed lookup for the given guid

getStructDefByName

Get the struct definition by it's name (unique)

/v2/types/structdef/name/{name}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/types/structdef/name/{name}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TypesRESTApi;

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

public class TypesRESTApiExample {

    public static void main(String[] args) {
        
        TypesRESTApi apiInstance = new TypesRESTApi();
        String name = name_example; // String | struct name
        try {
            AtlasStructDef result = apiInstance.getStructDefByName(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getStructDefByName");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TypesRESTApi;

public class TypesRESTApiExample {

    public static void main(String[] args) {
        TypesRESTApi apiInstance = new TypesRESTApi();
        String name = name_example; // String | struct name
        try {
            AtlasStructDef result = apiInstance.getStructDefByName(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getStructDefByName");
            e.printStackTrace();
        }
    }
}

String *name = name_example; // struct name

TypesRESTApi *apiInstance = [[TypesRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.TypesRESTApi()
var name = name_example; // {{String}} struct name

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new TypesRESTApi();
            var name = name_example;  // String | struct name

            try
            {
                AtlasStructDef result = apiInstance.getStructDefByName(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TypesRESTApi.getStructDefByName: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiTypesRESTApi();
$name = name_example; // String | struct name

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TypesRESTApi;

my $api_instance = WWW::SwaggerClient::TypesRESTApi->new();
my $name = name_example; # String | struct name

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

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

# create an instance of the API class
api_instance = swagger_client.TypesRESTApi()
name = name_example # String | struct name

try: 
    api_response = api_instance.get_struct_def_by_name(name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TypesRESTApi->getStructDefByName: %s\n" % e)

Parameters

Path parameters

Name	Description
name*	String struct name Required

Responses

Status: 200 - On successful lookup of the the struct definition by it's name

Schema

Status: 404 - On Failed lookup for the given name

getTypeDefByGuid

/v2/types/typedef/guid/{guid}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/types/typedef/guid/{guid}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TypesRESTApi;

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

public class TypesRESTApiExample {

    public static void main(String[] args) {
        
        TypesRESTApi apiInstance = new TypesRESTApi();
        String guid = guid_example; // String | GUID of the type
        try {
            AtlasBaseTypeDef result = apiInstance.getTypeDefByGuid(guid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getTypeDefByGuid");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TypesRESTApi;

public class TypesRESTApiExample {

    public static void main(String[] args) {
        TypesRESTApi apiInstance = new TypesRESTApi();
        String guid = guid_example; // String | GUID of the type
        try {
            AtlasBaseTypeDef result = apiInstance.getTypeDefByGuid(guid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getTypeDefByGuid");
            e.printStackTrace();
        }
    }
}

String *guid = guid_example; // GUID of the type

TypesRESTApi *apiInstance = [[TypesRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.TypesRESTApi()
var guid = guid_example; // {{String}} GUID of the type

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new TypesRESTApi();
            var guid = guid_example;  // String | GUID of the type

            try
            {
                AtlasBaseTypeDef result = apiInstance.getTypeDefByGuid(guid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TypesRESTApi.getTypeDefByGuid: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiTypesRESTApi();
$guid = guid_example; // String | GUID of the type

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TypesRESTApi;

my $api_instance = WWW::SwaggerClient::TypesRESTApi->new();
my $guid = guid_example; # String | GUID of the type

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

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

# create an instance of the API class
api_instance = swagger_client.TypesRESTApi()
guid = guid_example # String | GUID of the type

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

Parameters

Path parameters

Name	Description
guid*	String GUID of the type Required

Responses

Status: 200 - Successful lookup

Schema

Status: 404 - Failed lookup

getTypeDefByName

Get type definition by it's name

/v2/types/typedef/name/{name}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/types/typedef/name/{name}"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TypesRESTApi;

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

public class TypesRESTApiExample {

    public static void main(String[] args) {
        
        TypesRESTApi apiInstance = new TypesRESTApi();
        String name = name_example; // String | Type name
        try {
            AtlasBaseTypeDef result = apiInstance.getTypeDefByName(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getTypeDefByName");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TypesRESTApi;

public class TypesRESTApiExample {

    public static void main(String[] args) {
        TypesRESTApi apiInstance = new TypesRESTApi();
        String name = name_example; // String | Type name
        try {
            AtlasBaseTypeDef result = apiInstance.getTypeDefByName(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getTypeDefByName");
            e.printStackTrace();
        }
    }
}

String *name = name_example; // Type name

TypesRESTApi *apiInstance = [[TypesRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.TypesRESTApi()
var name = name_example; // {{String}} Type name

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new TypesRESTApi();
            var name = name_example;  // String | Type name

            try
            {
                AtlasBaseTypeDef result = apiInstance.getTypeDefByName(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TypesRESTApi.getTypeDefByName: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiTypesRESTApi();
$name = name_example; // String | Type name

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TypesRESTApi;

my $api_instance = WWW::SwaggerClient::TypesRESTApi->new();
my $name = name_example; # String | Type name

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

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

# create an instance of the API class
api_instance = swagger_client.TypesRESTApi()
name = name_example # String | Type name

try: 
    api_response = api_instance.get_type_def_by_name(name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TypesRESTApi->getTypeDefByName: %s\n" % e)

Parameters

Path parameters

Name	Description
name*	String Type name Required

Responses

Status: 200 - Successful lookup by name

Schema

Status: 404 - Failed lookup by name

getTypeDefHeaders

Bulk retrieval API for all type definitions returned as a list of minimal information header

/v2/types/typedefs/headers

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"/api/atlas//v2/types/typedefs/headers"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TypesRESTApi;

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

public class TypesRESTApiExample {

    public static void main(String[] args) {
        
        TypesRESTApi apiInstance = new TypesRESTApi();
        try {
            array[AtlasTypeDefHeader] result = apiInstance.getTypeDefHeaders();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getTypeDefHeaders");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TypesRESTApi;

public class TypesRESTApiExample {

    public static void main(String[] args) {
        TypesRESTApi apiInstance = new TypesRESTApi();
        try {
            array[AtlasTypeDefHeader] result = apiInstance.getTypeDefHeaders();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#getTypeDefHeaders");
            e.printStackTrace();
        }
    }
}


TypesRESTApi *apiInstance = [[TypesRESTApi alloc] init];

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

var AtlasRestApi = require('atlas_rest_api');

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new TypesRESTApi();

            try
            {
                array[AtlasTypeDefHeader] result = apiInstance.getTypeDefHeaders();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TypesRESTApi.getTypeDefHeaders: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiTypesRESTApi();

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TypesRESTApi;

my $api_instance = WWW::SwaggerClient::TypesRESTApi->new();

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

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

# create an instance of the API class
api_instance = swagger_client.TypesRESTApi()

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

Parameters

Responses

Status: 200 - Returns a list of AtlasTypeDefHeader matching the search criteria or an empty list if no match.

Schema

updateAtlasTypeDefs

Bulk update API for all types, changes detected in the type definitions would be persisted

/v2/types/typedefs

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"/api/atlas//v2/types/typedefs"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TypesRESTApi;

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

public class TypesRESTApiExample {

    public static void main(String[] args) {
        
        TypesRESTApi apiInstance = new TypesRESTApi();
        AtlasTypesDef body = ; // AtlasTypesDef | A composite object that captures all type definition changes
        try {
            AtlasTypesDef result = apiInstance.updateAtlasTypeDefs(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#updateAtlasTypeDefs");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TypesRESTApi;

public class TypesRESTApiExample {

    public static void main(String[] args) {
        TypesRESTApi apiInstance = new TypesRESTApi();
        AtlasTypesDef body = ; // AtlasTypesDef | A composite object that captures all type definition changes
        try {
            AtlasTypesDef result = apiInstance.updateAtlasTypeDefs(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TypesRESTApi#updateAtlasTypeDefs");
            e.printStackTrace();
        }
    }
}

AtlasTypesDef *body = ; // A composite object that captures all type definition changes (optional)

TypesRESTApi *apiInstance = [[TypesRESTApi alloc] init];

[apiInstance updateAtlasTypeDefsWith:body
              completionHandler: ^(AtlasTypesDef output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var AtlasRestApi = require('atlas_rest_api');

var api = new AtlasRestApi.TypesRESTApi()
var opts = { 
  'body':  // {{AtlasTypesDef}} A composite object that captures all type definition changes
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateAtlasTypeDefs(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new TypesRESTApi();
            var body = new AtlasTypesDef(); // AtlasTypesDef | A composite object that captures all type definition changes (optional) 

            try
            {
                AtlasTypesDef result = apiInstance.updateAtlasTypeDefs(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TypesRESTApi.updateAtlasTypeDefs: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiTypesRESTApi();
$body = ; // AtlasTypesDef | A composite object that captures all type definition changes

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::TypesRESTApi;

my $api_instance = WWW::SwaggerClient::TypesRESTApi->new();
my $body = WWW::SwaggerClient::Object::AtlasTypesDef->new(); # AtlasTypesDef | A composite object that captures all type definition changes

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

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

# create an instance of the API class
api_instance = swagger_client.TypesRESTApi()
body =  # AtlasTypesDef | A composite object that captures all type definition changes (optional)

try: 
    api_response = api_instance.update_atlas_type_defs(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TypesRESTApi->updateAtlasTypeDefs: %s\n" % e)

Parameters

Body parameters

Name	Description
body

Responses

Status: 200 - On successful update of requested type definitions

Schema

Atlas REST API

API and SDK Documentation

DiscoveryREST

addSavedSearch

Usage and SDK Samples

Parameters

Responses

Status: 201 - the saved search-object

basicSearchCreateFile

Usage and SDK Samples

Parameters

Responses

Status: 201 - Success

deleteSavedSearch

Usage and SDK Samples

Parameters

Responses

Status: 204 - Success

downloadSearchResultFile

Usage and SDK Samples

Parameters

Responses

Status: 200 -

dslSearchCreateFile

Usage and SDK Samples

Parameters

Responses

Status: 201 - Success

executeSavedSearchByGuid

Usage and SDK Samples

Parameters

Responses

Status: 200 - Atlas search result

executeSavedSearchByName

Usage and SDK Samples

Parameters

Responses

Status: 200 - Atlas search result

getSavedSearch

Usage and SDK Samples

Parameters

Responses

Status: 200 -

getSavedSearches

Usage and SDK Samples

Parameters

Responses

Status: 200 - list of all saved searches for given user

getSearchResultDownloadStatus

Usage and SDK Samples

Parameters

Responses

Status: 200 -

getSuggestions

Usage and SDK Samples

Parameters

Responses

Status: 200 -

quickSearch

Usage and SDK Samples

Parameters

Responses

Status: 200 - On successful search

Status: 400 - Tag/Entity doesn't exist or Tag/entity filter is present without tag/type name

quickSearch2

Usage and SDK Samples

Parameters

Responses

Status: 200 - On successful search

Status: 400 - Entity/attribute doesn't exist or entity filter is present without type name

relationSearch

Usage and SDK Samples

Parameters

Responses

Status: 200 - On successful search

relationSearch2

Usage and SDK Samples

Parameters

Responses

Status: 200 - On successful search