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

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

public class AssetRESTApiExample {

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

import io.swagger.client.api.AssetRESTApi;

public class AssetRESTApiExample {

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

VXAsset *body = ; //  (optional)

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.AssetRESTApi()
var opts = { 
  'body':  // {{VXAsset}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configTest(opts, callback);

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

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

            var apiInstance = new AssetRESTApi();
            var body = new VXAsset(); // VXAsset |  (optional) 

            try
            {
                VXResponse result = apiInstance.configTest(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetRESTApi.configTest: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAssetRESTApi();
$body = ; // VXAsset | 

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

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

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

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

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

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

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

public class AssetRESTApiExample {

    public static void main(String[] args) {
        
        AssetRESTApi apiInstance = new AssetRESTApi();
        try {
            VXLong result = apiInstance.countXAssets();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetRESTApi#countXAssets");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AssetRESTApi;

public class AssetRESTApiExample {

    public static void main(String[] args) {
        AssetRESTApi apiInstance = new AssetRESTApi();
        try {
            VXLong result = apiInstance.countXAssets();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetRESTApi#countXAssets");
            e.printStackTrace();
        }
    }
}

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

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

var RangerRestApi = require('ranger_rest_api');

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

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

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

            var apiInstance = new AssetRESTApi();

            try
            {
                VXLong result = apiInstance.countXAssets();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetRESTApi.countXAssets: " + e.Message );
            }
        }
    }
}

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

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

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

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

my $api_instance = WWW::SwaggerClient::AssetRESTApi->new();

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

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

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

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

public class AssetRESTApiExample {

    public static void main(String[] args) {
        
        AssetRESTApi apiInstance = new AssetRESTApi();
        try {
            VXLong result = apiInstance.countXResources();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetRESTApi#countXResources");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AssetRESTApi;

public class AssetRESTApiExample {

    public static void main(String[] args) {
        AssetRESTApi apiInstance = new AssetRESTApi();
        try {
            VXLong result = apiInstance.countXResources();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetRESTApi#countXResources");
            e.printStackTrace();
        }
    }
}

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

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

var RangerRestApi = require('ranger_rest_api');

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

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

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

            var apiInstance = new AssetRESTApi();

            try
            {
                VXLong result = apiInstance.countXResources();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetRESTApi.countXResources: " + e.Message );
            }
        }
    }
}

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

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

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

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

my $api_instance = WWW::SwaggerClient::AssetRESTApi->new();

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

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

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

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

public class AssetRESTApiExample {

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

import io.swagger.client.api.AssetRESTApi;

public class AssetRESTApiExample {

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

VXAsset *body = ; //  (optional)

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.AssetRESTApi()
var opts = { 
  'body':  // {{VXAsset}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createXAsset(opts, callback);

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

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

            var apiInstance = new AssetRESTApi();
            var body = new VXAsset(); // VXAsset |  (optional) 

            try
            {
                VXAsset result = apiInstance.createXAsset(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetRESTApi.createXAsset: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAssetRESTApi();
$body = ; // VXAsset | 

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

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

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

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

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

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

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

public class AssetRESTApiExample {

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

import io.swagger.client.api.AssetRESTApi;

public class AssetRESTApiExample {

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

VXResource *body = ; //  (optional)

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.AssetRESTApi()
var opts = { 
  'body':  // {{VXResource}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createXResource(opts, callback);

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

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

            var apiInstance = new AssetRESTApi();
            var body = new VXResource(); // VXResource |  (optional) 

            try
            {
                VXResource result = apiInstance.createXResource(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetRESTApi.createXResource: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAssetRESTApi();
$body = ; // VXResource | 

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

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

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

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

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

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

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

public class AssetRESTApiExample {

    public static void main(String[] args) {
        
        AssetRESTApi apiInstance = new AssetRESTApi();
        Long id = 789; // Long | 
        try {
            apiInstance.deleteXAsset(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetRESTApi#deleteXAsset");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AssetRESTApi;

public class AssetRESTApiExample {

    public static void main(String[] args) {
        AssetRESTApi apiInstance = new AssetRESTApi();
        Long id = 789; // Long | 
        try {
            apiInstance.deleteXAsset(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetRESTApi#deleteXAsset");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.AssetRESTApi()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new AssetRESTApi();
            var id = 789;  // Long | 

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

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

$api_instance = new Swagger\Client\ApiAssetRESTApi();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::AssetRESTApi->new();
my $id = 789; # Long | 

eval { 
    $api_instance->deleteXAsset(id => $id);
};
if ($@) {
    warn "Exception when calling AssetRESTApi->deleteXAsset: $@\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.AssetRESTApi()
id = 789 # Long | 

try: 
    api_instance.delete_x_asset(id)
except ApiException as e:
    print("Exception when calling AssetRESTApi->deleteXAsset: %s\n" % e)

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

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

public class AssetRESTApiExample {

    public static void main(String[] args) {
        
        AssetRESTApi apiInstance = new AssetRESTApi();
        Long id = 789; // Long | 
        try {
            apiInstance.deleteXResource(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetRESTApi#deleteXResource");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AssetRESTApi;

public class AssetRESTApiExample {

    public static void main(String[] args) {
        AssetRESTApi apiInstance = new AssetRESTApi();
        Long id = 789; // Long | 
        try {
            apiInstance.deleteXResource(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetRESTApi#deleteXResource");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.AssetRESTApi()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new AssetRESTApi();
            var id = 789;  // Long | 

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

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

$api_instance = new Swagger\Client\ApiAssetRESTApi();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::AssetRESTApi->new();
my $id = 789; # Long | 

eval { 
    $api_instance->deleteXResource(id => $id);
};
if ($@) {
    warn "Exception when calling AssetRESTApi->deleteXResource: $@\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.AssetRESTApi()
id = 789 # Long | 

try: 
    api_instance.delete_x_resource(id)
except ApiException as e:
    print("Exception when calling AssetRESTApi->deleteXResource: %s\n" % e)

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

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

public class AssetRESTApiExample {

    public static void main(String[] args) {
        
        AssetRESTApi apiInstance = new AssetRESTApi();
        try {
            VXAccessAuditList result = apiInstance.getAccessLogs();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetRESTApi#getAccessLogs");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AssetRESTApi;

public class AssetRESTApiExample {

    public static void main(String[] args) {
        AssetRESTApi apiInstance = new AssetRESTApi();
        try {
            VXAccessAuditList result = apiInstance.getAccessLogs();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetRESTApi#getAccessLogs");
            e.printStackTrace();
        }
    }
}

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

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

var RangerRestApi = require('ranger_rest_api');

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

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

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

            var apiInstance = new AssetRESTApi();

            try
            {
                VXAccessAuditList result = apiInstance.getAccessLogs();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetRESTApi.getAccessLogs: " + e.Message );
            }
        }
    }
}

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

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

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

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

my $api_instance = WWW::SwaggerClient::AssetRESTApi->new();

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

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

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

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

public class AssetRESTApiExample {

    public static void main(String[] args) {
        
        AssetRESTApi apiInstance = new AssetRESTApi();
        try {
            VXTrxLogList result = apiInstance.getReportLogs();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetRESTApi#getReportLogs");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AssetRESTApi;

public class AssetRESTApiExample {

    public static void main(String[] args) {
        AssetRESTApi apiInstance = new AssetRESTApi();
        try {
            VXTrxLogList result = apiInstance.getReportLogs();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetRESTApi#getReportLogs");
            e.printStackTrace();
        }
    }
}

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

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

var RangerRestApi = require('ranger_rest_api');

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

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

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

            var apiInstance = new AssetRESTApi();

            try
            {
                VXTrxLogList result = apiInstance.getReportLogs();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetRESTApi.getReportLogs: " + e.Message );
            }
        }
    }
}

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

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

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

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

my $api_instance = WWW::SwaggerClient::AssetRESTApi->new();

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

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

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

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

public class AssetRESTApiExample {

    public static void main(String[] args) {
        
        AssetRESTApi apiInstance = new AssetRESTApi();
        String transactionId = transactionId_example; // String | 
        try {
            VXTrxLogList result = apiInstance.getTransactionReport(transactionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetRESTApi#getTransactionReport");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AssetRESTApi;

public class AssetRESTApiExample {

    public static void main(String[] args) {
        AssetRESTApi apiInstance = new AssetRESTApi();
        String transactionId = transactionId_example; // String | 
        try {
            VXTrxLogList result = apiInstance.getTransactionReport(transactionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetRESTApi#getTransactionReport");
            e.printStackTrace();
        }
    }
}

String *transactionId = transactionId_example; // 

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

[apiInstance getTransactionReportWith:transactionId
              completionHandler: ^(VXTrxLogList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.AssetRESTApi()
var transactionId = transactionId_example; // {{String}} 

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

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

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

            var apiInstance = new AssetRESTApi();
            var transactionId = transactionId_example;  // String | 

            try
            {
                VXTrxLogList result = apiInstance.getTransactionReport(transactionId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetRESTApi.getTransactionReport: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAssetRESTApi();
$transactionId = transactionId_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::AssetRESTApi->new();
my $transactionId = transactionId_example; # String | 

eval { 
    my $result = $api_instance->getTransactionReport(transactionId => $transactionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AssetRESTApi->getTransactionReport: $@\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.AssetRESTApi()
transactionId = transactionId_example # String | 

try: 
    api_response = api_instance.get_transaction_report(transactionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AssetRESTApi->getTransactionReport: %s\n" % e)

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

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

public class AssetRESTApiExample {

    public static void main(String[] args) {
        
        AssetRESTApi apiInstance = new AssetRESTApi();
        try {
            VXUgsyncAuditInfoList result = apiInstance.getUgsyncAudits();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetRESTApi#getUgsyncAudits");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AssetRESTApi;

public class AssetRESTApiExample {

    public static void main(String[] args) {
        AssetRESTApi apiInstance = new AssetRESTApi();
        try {
            VXUgsyncAuditInfoList result = apiInstance.getUgsyncAudits();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetRESTApi#getUgsyncAudits");
            e.printStackTrace();
        }
    }
}

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

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

var RangerRestApi = require('ranger_rest_api');

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

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

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

            var apiInstance = new AssetRESTApi();

            try
            {
                VXUgsyncAuditInfoList result = apiInstance.getUgsyncAudits();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetRESTApi.getUgsyncAudits: " + e.Message );
            }
        }
    }
}

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

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

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

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

my $api_instance = WWW::SwaggerClient::AssetRESTApi->new();

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

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

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

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

public class AssetRESTApiExample {

    public static void main(String[] args) {
        
        AssetRESTApi apiInstance = new AssetRESTApi();
        String syncSource = syncSource_example; // String | 
        try {
            VXUgsyncAuditInfoList result = apiInstance.getUgsyncAuditsBySyncSource(syncSource);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetRESTApi#getUgsyncAuditsBySyncSource");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AssetRESTApi;

public class AssetRESTApiExample {

    public static void main(String[] args) {
        AssetRESTApi apiInstance = new AssetRESTApi();
        String syncSource = syncSource_example; // String | 
        try {
            VXUgsyncAuditInfoList result = apiInstance.getUgsyncAuditsBySyncSource(syncSource);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetRESTApi#getUgsyncAuditsBySyncSource");
            e.printStackTrace();
        }
    }
}

String *syncSource = syncSource_example; // 

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

[apiInstance getUgsyncAuditsBySyncSourceWith:syncSource
              completionHandler: ^(VXUgsyncAuditInfoList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.AssetRESTApi()
var syncSource = syncSource_example; // {{String}} 

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

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

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

            var apiInstance = new AssetRESTApi();
            var syncSource = syncSource_example;  // String | 

            try
            {
                VXUgsyncAuditInfoList result = apiInstance.getUgsyncAuditsBySyncSource(syncSource);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetRESTApi.getUgsyncAuditsBySyncSource: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAssetRESTApi();
$syncSource = syncSource_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::AssetRESTApi->new();
my $syncSource = syncSource_example; # String | 

eval { 
    my $result = $api_instance->getUgsyncAuditsBySyncSource(syncSource => $syncSource);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AssetRESTApi->getUgsyncAuditsBySyncSource: $@\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.AssetRESTApi()
syncSource = syncSource_example # String | 

try: 
    api_response = api_instance.get_ugsync_audits_by_sync_source(syncSource)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AssetRESTApi->getUgsyncAuditsBySyncSource: %s\n" % e)

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

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

public class AssetRESTApiExample {

    public static void main(String[] args) {
        
        AssetRESTApi apiInstance = new AssetRESTApi();
        Long id = 789; // Long | 
        try {
            VXAsset result = apiInstance.getXAsset(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetRESTApi#getXAsset");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AssetRESTApi;

public class AssetRESTApiExample {

    public static void main(String[] args) {
        AssetRESTApi apiInstance = new AssetRESTApi();
        Long id = 789; // Long | 
        try {
            VXAsset result = apiInstance.getXAsset(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetRESTApi#getXAsset");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.AssetRESTApi()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new AssetRESTApi();
            var id = 789;  // Long | 

            try
            {
                VXAsset result = apiInstance.getXAsset(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetRESTApi.getXAsset: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAssetRESTApi();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::AssetRESTApi->new();
my $id = 789; # Long | 

eval { 
    my $result = $api_instance->getXAsset(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AssetRESTApi->getXAsset: $@\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.AssetRESTApi()
id = 789 # Long | 

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

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

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

public class AssetRESTApiExample {

    public static void main(String[] args) {
        
        AssetRESTApi apiInstance = new AssetRESTApi();
        Long id = 789; // Long | 
        try {
            VXResource result = apiInstance.getXResource(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetRESTApi#getXResource");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AssetRESTApi;

public class AssetRESTApiExample {

    public static void main(String[] args) {
        AssetRESTApi apiInstance = new AssetRESTApi();
        Long id = 789; // Long | 
        try {
            VXResource result = apiInstance.getXResource(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetRESTApi#getXResource");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.AssetRESTApi()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new AssetRESTApi();
            var id = 789;  // Long | 

            try
            {
                VXResource result = apiInstance.getXResource(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetRESTApi.getXResource: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAssetRESTApi();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::AssetRESTApi->new();
my $id = 789; # Long | 

eval { 
    my $result = $api_instance->getXResource(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AssetRESTApi->getXResource: $@\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.AssetRESTApi()
id = 789 # Long | 

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

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

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

public class AssetRESTApiExample {

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

import io.swagger.client.api.AssetRESTApi;

public class AssetRESTApiExample {

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

VXPolicy *body = ; //  (optional)

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.AssetRESTApi()
var opts = { 
  'body':  // {{VXPolicy}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.grantPermission(opts, callback);

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

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

            var apiInstance = new AssetRESTApi();
            var body = new VXPolicy(); // VXPolicy |  (optional) 

            try
            {
                VXPolicy result = apiInstance.grantPermission(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetRESTApi.grantPermission: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAssetRESTApi();
$body = ; // VXPolicy | 

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

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

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

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

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

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

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

public class AssetRESTApiExample {

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

import io.swagger.client.api.AssetRESTApi;

public class AssetRESTApiExample {

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

VXPolicy *body = ; //  (optional)

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.AssetRESTApi()
var opts = { 
  'body':  // {{VXPolicy}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.revokePermission(opts, callback);

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

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

            var apiInstance = new AssetRESTApi();
            var body = new VXPolicy(); // VXPolicy |  (optional) 

            try
            {
                VXPolicy result = apiInstance.revokePermission(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetRESTApi.revokePermission: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAssetRESTApi();
$body = ; // VXPolicy | 

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

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

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

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

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

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

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

public class AssetRESTApiExample {

    public static void main(String[] args) {
        
        AssetRESTApi apiInstance = new AssetRESTApi();
        try {
            VXAssetList result = apiInstance.searchXAssets();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetRESTApi#searchXAssets");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AssetRESTApi;

public class AssetRESTApiExample {

    public static void main(String[] args) {
        AssetRESTApi apiInstance = new AssetRESTApi();
        try {
            VXAssetList result = apiInstance.searchXAssets();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetRESTApi#searchXAssets");
            e.printStackTrace();
        }
    }
}

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

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

var RangerRestApi = require('ranger_rest_api');

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

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

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

            var apiInstance = new AssetRESTApi();

            try
            {
                VXAssetList result = apiInstance.searchXAssets();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetRESTApi.searchXAssets: " + e.Message );
            }
        }
    }
}

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

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

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

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

my $api_instance = WWW::SwaggerClient::AssetRESTApi->new();

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

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

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

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

public class AssetRESTApiExample {

    public static void main(String[] args) {
        
        AssetRESTApi apiInstance = new AssetRESTApi();
        try {
            VXPolicyExportAuditList result = apiInstance.searchXPolicyExportAudits();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetRESTApi#searchXPolicyExportAudits");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AssetRESTApi;

public class AssetRESTApiExample {

    public static void main(String[] args) {
        AssetRESTApi apiInstance = new AssetRESTApi();
        try {
            VXPolicyExportAuditList result = apiInstance.searchXPolicyExportAudits();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetRESTApi#searchXPolicyExportAudits");
            e.printStackTrace();
        }
    }
}

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

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

var RangerRestApi = require('ranger_rest_api');

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

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

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

            var apiInstance = new AssetRESTApi();

            try
            {
                VXPolicyExportAuditList result = apiInstance.searchXPolicyExportAudits();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetRESTApi.searchXPolicyExportAudits: " + e.Message );
            }
        }
    }
}

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

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

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

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

my $api_instance = WWW::SwaggerClient::AssetRESTApi->new();

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

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

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

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

public class AssetRESTApiExample {

    public static void main(String[] args) {
        
        AssetRESTApi apiInstance = new AssetRESTApi();
        try {
            VXResourceList result = apiInstance.searchXResources();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetRESTApi#searchXResources");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AssetRESTApi;

public class AssetRESTApiExample {

    public static void main(String[] args) {
        AssetRESTApi apiInstance = new AssetRESTApi();
        try {
            VXResourceList result = apiInstance.searchXResources();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetRESTApi#searchXResources");
            e.printStackTrace();
        }
    }
}

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

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

var RangerRestApi = require('ranger_rest_api');

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

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

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

            var apiInstance = new AssetRESTApi();

            try
            {
                VXResourceList result = apiInstance.searchXResources();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetRESTApi.searchXResources: " + e.Message );
            }
        }
    }
}

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

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

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

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

my $api_instance = WWW::SwaggerClient::AssetRESTApi->new();

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

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

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

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

public class AssetRESTApiExample {

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

import io.swagger.client.api.AssetRESTApi;

public class AssetRESTApiExample {

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

VXAsset *body = ; //  (optional)

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.AssetRESTApi()
var opts = { 
  'body':  // {{VXAsset}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateXAsset(opts, callback);

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

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

            var apiInstance = new AssetRESTApi();
            var body = new VXAsset(); // VXAsset |  (optional) 

            try
            {
                VXAsset result = apiInstance.updateXAsset(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetRESTApi.updateXAsset: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAssetRESTApi();
$body = ; // VXAsset | 

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

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

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

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

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

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

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

public class AssetRESTApiExample {

    public static void main(String[] args) {
        
        AssetRESTApi apiInstance = new AssetRESTApi();
        Long id = 789; // Long | 
        VXResource body = ; // VXResource | 
        try {
            VXResource result = apiInstance.updateXResource(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetRESTApi#updateXResource");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AssetRESTApi;

public class AssetRESTApiExample {

    public static void main(String[] args) {
        AssetRESTApi apiInstance = new AssetRESTApi();
        Long id = 789; // Long | 
        VXResource body = ; // VXResource | 
        try {
            VXResource result = apiInstance.updateXResource(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetRESTApi#updateXResource");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 
VXResource *body = ; //  (optional)

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.AssetRESTApi()
var id = 789; // {{Long}} 
var opts = { 
  'body':  // {{VXResource}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateXResource(id, opts, callback);

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

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

            var apiInstance = new AssetRESTApi();
            var id = 789;  // Long | 
            var body = new VXResource(); // VXResource |  (optional) 

            try
            {
                VXResource result = apiInstance.updateXResource(id, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetRESTApi.updateXResource: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAssetRESTApi();
$id = 789; // Long | 
$body = ; // VXResource | 

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

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

my $api_instance = WWW::SwaggerClient::AssetRESTApi->new();
my $id = 789; # Long | 
my $body = WWW::SwaggerClient::Object::VXResource->new(); # VXResource | 

eval { 
    my $result = $api_instance->updateXResource(id => $id, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AssetRESTApi->updateXResource: $@\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.AssetRESTApi()
id = 789 # Long | 
body =  # VXResource |  (optional)

try: 
    api_response = api_instance.update_x_resource(id, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AssetRESTApi->updateXResource: %s\n" % e)

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

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

public class AuditMetricsRESTApiExample {

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

import io.swagger.client.api.AuditMetricsRESTApi;

public class AuditMetricsRESTApiExample {

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

RangerAuditMetrics *body = ; //  (optional)

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.AuditMetricsRESTApi()
var opts = { 
  'body':  // {{RangerAuditMetrics}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createAuditMetrics(opts, callback);

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

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

            var apiInstance = new AuditMetricsRESTApi();
            var body = new RangerAuditMetrics(); // RangerAuditMetrics |  (optional) 

            try
            {
                RangerAuditMetrics result = apiInstance.createAuditMetrics(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuditMetricsRESTApi.createAuditMetrics: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAuditMetricsRESTApi();
$body = ; // RangerAuditMetrics | 

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

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

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

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

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

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

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

public class AuditMetricsRESTApiExample {

    public static void main(String[] args) {
        
        AuditMetricsRESTApi apiInstance = new AuditMetricsRESTApi();
        Integer retentionPeriod = 56; // Integer | 
        String serviceName = serviceName_example; // String | 
        String serviceType = serviceType_example; // String | 
        try {
            apiInstance.deleteRangerAuditMetrics(retentionPeriod, serviceName, serviceType);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuditMetricsRESTApi#deleteRangerAuditMetrics");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AuditMetricsRESTApi;

public class AuditMetricsRESTApiExample {

    public static void main(String[] args) {
        AuditMetricsRESTApi apiInstance = new AuditMetricsRESTApi();
        Integer retentionPeriod = 56; // Integer | 
        String serviceName = serviceName_example; // String | 
        String serviceType = serviceType_example; // String | 
        try {
            apiInstance.deleteRangerAuditMetrics(retentionPeriod, serviceName, serviceType);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuditMetricsRESTApi#deleteRangerAuditMetrics");
            e.printStackTrace();
        }
    }
}

Integer *retentionPeriod = 56; //  (optional) (default to 7)
String *serviceName = serviceName_example; //  (optional)
String *serviceType = serviceType_example; //  (optional)

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

[apiInstance deleteRangerAuditMetricsWith:retentionPeriod
    serviceName:serviceName
    serviceType:serviceType
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.AuditMetricsRESTApi()
var opts = { 
  'retentionPeriod': 56, // {{Integer}} 
  'serviceName': serviceName_example, // {{String}} 
  'serviceType': serviceType_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteRangerAuditMetrics(opts, callback);

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

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

            var apiInstance = new AuditMetricsRESTApi();
            var retentionPeriod = 56;  // Integer |  (optional)  (default to 7)
            var serviceName = serviceName_example;  // String |  (optional) 
            var serviceType = serviceType_example;  // String |  (optional) 

            try
            {
                apiInstance.deleteRangerAuditMetrics(retentionPeriod, serviceName, serviceType);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuditMetricsRESTApi.deleteRangerAuditMetrics: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAuditMetricsRESTApi();
$retentionPeriod = 56; // Integer | 
$serviceName = serviceName_example; // String | 
$serviceType = serviceType_example; // String | 

try {
    $api_instance->deleteRangerAuditMetrics($retentionPeriod, $serviceName, $serviceType);
} catch (Exception $e) {
    echo 'Exception when calling AuditMetricsRESTApi->deleteRangerAuditMetrics: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::AuditMetricsRESTApi->new();
my $retentionPeriod = 56; # Integer | 
my $serviceName = serviceName_example; # String | 
my $serviceType = serviceType_example; # String | 

eval { 
    $api_instance->deleteRangerAuditMetrics(retentionPeriod => $retentionPeriod, serviceName => $serviceName, serviceType => $serviceType);
};
if ($@) {
    warn "Exception when calling AuditMetricsRESTApi->deleteRangerAuditMetrics: $@\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.AuditMetricsRESTApi()
retentionPeriod = 56 # Integer |  (optional) (default to 7)
serviceName = serviceName_example # String |  (optional)
serviceType = serviceType_example # String |  (optional)

try: 
    api_instance.delete_ranger_audit_metrics(retentionPeriod=retentionPeriod, serviceName=serviceName, serviceType=serviceType)
except ApiException as e:
    print("Exception when calling AuditMetricsRESTApi->deleteRangerAuditMetrics: %s\n" % e)

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

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

public class AuditMetricsRESTApiExample {

    public static void main(String[] args) {
        
        AuditMetricsRESTApi apiInstance = new AuditMetricsRESTApi();
        try {
            RangerAuditMetricsList result = apiInstance.getAllLatestRangerAuditMetrics();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuditMetricsRESTApi#getAllLatestRangerAuditMetrics");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AuditMetricsRESTApi;

public class AuditMetricsRESTApiExample {

    public static void main(String[] args) {
        AuditMetricsRESTApi apiInstance = new AuditMetricsRESTApi();
        try {
            RangerAuditMetricsList result = apiInstance.getAllLatestRangerAuditMetrics();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuditMetricsRESTApi#getAllLatestRangerAuditMetrics");
            e.printStackTrace();
        }
    }
}

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

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

var RangerRestApi = require('ranger_rest_api');

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

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

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

            var apiInstance = new AuditMetricsRESTApi();

            try
            {
                RangerAuditMetricsList result = apiInstance.getAllLatestRangerAuditMetrics();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuditMetricsRESTApi.getAllLatestRangerAuditMetrics: " + e.Message );
            }
        }
    }
}

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

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

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

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

my $api_instance = WWW::SwaggerClient::AuditMetricsRESTApi->new();

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

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

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

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

public class AuditMetricsRESTApiExample {

    public static void main(String[] args) {
        
        AuditMetricsRESTApi apiInstance = new AuditMetricsRESTApi();
        Long id = 789; // Long | 
        try {
            RangerAuditMetrics result = apiInstance.getAuditMetrics(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuditMetricsRESTApi#getAuditMetrics");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AuditMetricsRESTApi;

public class AuditMetricsRESTApiExample {

    public static void main(String[] args) {
        AuditMetricsRESTApi apiInstance = new AuditMetricsRESTApi();
        Long id = 789; // Long | 
        try {
            RangerAuditMetrics result = apiInstance.getAuditMetrics(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuditMetricsRESTApi#getAuditMetrics");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.AuditMetricsRESTApi()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new AuditMetricsRESTApi();
            var id = 789;  // Long | 

            try
            {
                RangerAuditMetrics result = apiInstance.getAuditMetrics(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuditMetricsRESTApi.getAuditMetrics: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAuditMetricsRESTApi();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::AuditMetricsRESTApi->new();
my $id = 789; # Long | 

eval { 
    my $result = $api_instance->getAuditMetrics(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuditMetricsRESTApi->getAuditMetrics: $@\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.AuditMetricsRESTApi()
id = 789 # Long | 

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

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

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

public class AuditMetricsRESTApiExample {

    public static void main(String[] args) {
        
        AuditMetricsRESTApi apiInstance = new AuditMetricsRESTApi();
        try {
            RangerAuditMetricsListByHours result = apiInstance.getDailyAuditMetrics();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuditMetricsRESTApi#getDailyAuditMetrics");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AuditMetricsRESTApi;

public class AuditMetricsRESTApiExample {

    public static void main(String[] args) {
        AuditMetricsRESTApi apiInstance = new AuditMetricsRESTApi();
        try {
            RangerAuditMetricsListByHours result = apiInstance.getDailyAuditMetrics();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuditMetricsRESTApi#getDailyAuditMetrics");
            e.printStackTrace();
        }
    }
}

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

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

var RangerRestApi = require('ranger_rest_api');

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

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

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

            var apiInstance = new AuditMetricsRESTApi();

            try
            {
                RangerAuditMetricsListByHours result = apiInstance.getDailyAuditMetrics();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuditMetricsRESTApi.getDailyAuditMetrics: " + e.Message );
            }
        }
    }
}

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

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

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

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

my $api_instance = WWW::SwaggerClient::AuditMetricsRESTApi->new();

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

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

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

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

public class AuditMetricsRESTApiExample {

    public static void main(String[] args) {
        
        AuditMetricsRESTApi apiInstance = new AuditMetricsRESTApi();
        Integer olderThanInDays = 56; // Integer | 
        try {
            RangerAuditMetricsListByDays result = apiInstance.getDaysAuditMetrics(olderThanInDays);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuditMetricsRESTApi#getDaysAuditMetrics");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AuditMetricsRESTApi;

public class AuditMetricsRESTApiExample {

    public static void main(String[] args) {
        AuditMetricsRESTApi apiInstance = new AuditMetricsRESTApi();
        Integer olderThanInDays = 56; // Integer | 
        try {
            RangerAuditMetricsListByDays result = apiInstance.getDaysAuditMetrics(olderThanInDays);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuditMetricsRESTApi#getDaysAuditMetrics");
            e.printStackTrace();
        }
    }
}

Integer *olderThanInDays = 56; //  (optional) (default to 7)

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

[apiInstance getDaysAuditMetricsWith:olderThanInDays
              completionHandler: ^(RangerAuditMetricsListByDays output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.AuditMetricsRESTApi()
var opts = { 
  'olderThanInDays': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getDaysAuditMetrics(opts, callback);

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

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

            var apiInstance = new AuditMetricsRESTApi();
            var olderThanInDays = 56;  // Integer |  (optional)  (default to 7)

            try
            {
                RangerAuditMetricsListByDays result = apiInstance.getDaysAuditMetrics(olderThanInDays);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuditMetricsRESTApi.getDaysAuditMetrics: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAuditMetricsRESTApi();
$olderThanInDays = 56; // Integer | 

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

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

my $api_instance = WWW::SwaggerClient::AuditMetricsRESTApi->new();
my $olderThanInDays = 56; # Integer | 

eval { 
    my $result = $api_instance->getDaysAuditMetrics(olderThanInDays => $olderThanInDays);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuditMetricsRESTApi->getDaysAuditMetrics: $@\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.AuditMetricsRESTApi()
olderThanInDays = 56 # Integer |  (optional) (default to 7)

try: 
    api_response = api_instance.get_days_audit_metrics(olderThanInDays=olderThanInDays)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuditMetricsRESTApi->getDaysAuditMetrics: %s\n" % e)

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

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

public class AuditMetricsRESTApiExample {

    public static void main(String[] args) {
        
        AuditMetricsRESTApi apiInstance = new AuditMetricsRESTApi();
        String servicename = servicename_example; // String | 
        String servicetype = servicetype_example; // String | 
        try {
            RangerAuditMetrics result = apiInstance.getLatestAuditMetrics(servicename, servicetype);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuditMetricsRESTApi#getLatestAuditMetrics");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AuditMetricsRESTApi;

public class AuditMetricsRESTApiExample {

    public static void main(String[] args) {
        AuditMetricsRESTApi apiInstance = new AuditMetricsRESTApi();
        String servicename = servicename_example; // String | 
        String servicetype = servicetype_example; // String | 
        try {
            RangerAuditMetrics result = apiInstance.getLatestAuditMetrics(servicename, servicetype);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuditMetricsRESTApi#getLatestAuditMetrics");
            e.printStackTrace();
        }
    }
}

String *servicename = servicename_example; // 
String *servicetype = servicetype_example; // 

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

[apiInstance getLatestAuditMetricsWith:servicename
    servicetype:servicetype
              completionHandler: ^(RangerAuditMetrics output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.AuditMetricsRESTApi()
var servicename = servicename_example; // {{String}} 
var servicetype = servicetype_example; // {{String}} 

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

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

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

            var apiInstance = new AuditMetricsRESTApi();
            var servicename = servicename_example;  // String | 
            var servicetype = servicetype_example;  // String | 

            try
            {
                RangerAuditMetrics result = apiInstance.getLatestAuditMetrics(servicename, servicetype);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuditMetricsRESTApi.getLatestAuditMetrics: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAuditMetricsRESTApi();
$servicename = servicename_example; // String | 
$servicetype = servicetype_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::AuditMetricsRESTApi->new();
my $servicename = servicename_example; # String | 
my $servicetype = servicetype_example; # String | 

eval { 
    my $result = $api_instance->getLatestAuditMetrics(servicename => $servicename, servicetype => $servicetype);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuditMetricsRESTApi->getLatestAuditMetrics: $@\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.AuditMetricsRESTApi()
servicename = servicename_example # String | 
servicetype = servicetype_example # String | 

try: 
    api_response = api_instance.get_latest_audit_metrics(servicename, servicetype)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuditMetricsRESTApi->getLatestAuditMetrics: %s\n" % e)

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

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

public class MetricsRESTApiExample {

    public static void main(String[] args) {
        
        MetricsRESTApi apiInstance = new MetricsRESTApi();
        try {
            map['String', Object] result = apiInstance.getMetricsJson();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MetricsRESTApi#getMetricsJson");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MetricsRESTApi;

public class MetricsRESTApiExample {

    public static void main(String[] args) {
        MetricsRESTApi apiInstance = new MetricsRESTApi();
        try {
            map['String', Object] result = apiInstance.getMetricsJson();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MetricsRESTApi#getMetricsJson");
            e.printStackTrace();
        }
    }
}

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

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

var RangerRestApi = require('ranger_rest_api');

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

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

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

            var apiInstance = new MetricsRESTApi();

            try
            {
                map['String', Object] result = apiInstance.getMetricsJson();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MetricsRESTApi.getMetricsJson: " + e.Message );
            }
        }
    }
}

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

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

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

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

my $api_instance = WWW::SwaggerClient::MetricsRESTApi->new();

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

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

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

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

public class MetricsRESTApiExample {

    public static void main(String[] args) {
        
        MetricsRESTApi apiInstance = new MetricsRESTApi();
        try {
            'String' result = apiInstance.getMetricsPrometheus();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MetricsRESTApi#getMetricsPrometheus");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MetricsRESTApi;

public class MetricsRESTApiExample {

    public static void main(String[] args) {
        MetricsRESTApi apiInstance = new MetricsRESTApi();
        try {
            'String' result = apiInstance.getMetricsPrometheus();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MetricsRESTApi#getMetricsPrometheus");
            e.printStackTrace();
        }
    }
}

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

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

var RangerRestApi = require('ranger_rest_api');

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

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

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

            var apiInstance = new MetricsRESTApi();

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

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

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

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

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

my $api_instance = WWW::SwaggerClient::MetricsRESTApi->new();

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

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

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

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

public class MetricsRESTApiExample {

    public static void main(String[] args) {
        
        MetricsRESTApi apiInstance = new MetricsRESTApi();
        try {
            RangerMetrics result = apiInstance.getStatus();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MetricsRESTApi#getStatus");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MetricsRESTApi;

public class MetricsRESTApiExample {

    public static void main(String[] args) {
        MetricsRESTApi apiInstance = new MetricsRESTApi();
        try {
            RangerMetrics result = apiInstance.getStatus();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MetricsRESTApi#getStatus");
            e.printStackTrace();
        }
    }
}

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

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

var RangerRestApi = require('ranger_rest_api');

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

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

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

            var apiInstance = new MetricsRESTApi();

            try
            {
                RangerMetrics result = apiInstance.getStatus();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MetricsRESTApi.getStatus: " + e.Message );
            }
        }
    }
}

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

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

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

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

my $api_instance = WWW::SwaggerClient::MetricsRESTApi->new();

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

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

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

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

public class PublicAPIsApiExample {

    public static void main(String[] args) {
        
        PublicAPIsApi apiInstance = new PublicAPIsApi();
        try {
            VXLong result = apiInstance.countPolicies2();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsApi#countPolicies2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsApi;

public class PublicAPIsApiExample {

    public static void main(String[] args) {
        PublicAPIsApi apiInstance = new PublicAPIsApi();
        try {
            VXLong result = apiInstance.countPolicies2();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsApi#countPolicies2");
            e.printStackTrace();
        }
    }
}

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

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

var RangerRestApi = require('ranger_rest_api');

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

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

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

            var apiInstance = new PublicAPIsApi();

            try
            {
                VXLong result = apiInstance.countPolicies2();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsApi.countPolicies2: " + e.Message );
            }
        }
    }
}

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

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

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

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

my $api_instance = WWW::SwaggerClient::PublicAPIsApi->new();

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

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

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

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

public class PublicAPIsApiExample {

    public static void main(String[] args) {
        
        PublicAPIsApi apiInstance = new PublicAPIsApi();
        try {
            VXLong result = apiInstance.countRepositories();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsApi#countRepositories");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsApi;

public class PublicAPIsApiExample {

    public static void main(String[] args) {
        PublicAPIsApi apiInstance = new PublicAPIsApi();
        try {
            VXLong result = apiInstance.countRepositories();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsApi#countRepositories");
            e.printStackTrace();
        }
    }
}

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

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

var RangerRestApi = require('ranger_rest_api');

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

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

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

            var apiInstance = new PublicAPIsApi();

            try
            {
                VXLong result = apiInstance.countRepositories();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsApi.countRepositories: " + e.Message );
            }
        }
    }
}

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

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

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

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

my $api_instance = WWW::SwaggerClient::PublicAPIsApi->new();

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

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

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

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

public class PublicAPIsApiExample {

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

import io.swagger.client.api.PublicAPIsApi;

public class PublicAPIsApiExample {

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

VXPolicy *body = ; //  (optional)

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsApi()
var opts = { 
  'body':  // {{VXPolicy}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createPolicy2(opts, callback);

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

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

            var apiInstance = new PublicAPIsApi();
            var body = new VXPolicy(); // VXPolicy |  (optional) 

            try
            {
                VXPolicy result = apiInstance.createPolicy2(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsApi.createPolicy2: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiPublicAPIsApi();
$body = ; // VXPolicy | 

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

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

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

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

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

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

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

public class PublicAPIsApiExample {

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

import io.swagger.client.api.PublicAPIsApi;

public class PublicAPIsApiExample {

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

VXRepository *body = ; //  (optional)

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsApi()
var opts = { 
  'body':  // {{VXRepository}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createRepository(opts, callback);

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

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

            var apiInstance = new PublicAPIsApi();
            var body = new VXRepository(); // VXRepository |  (optional) 

            try
            {
                VXRepository result = apiInstance.createRepository(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsApi.createRepository: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiPublicAPIsApi();
$body = ; // VXRepository | 

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

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

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

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

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

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

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

public class PublicAPIsApiExample {

    public static void main(String[] args) {
        
        PublicAPIsApi apiInstance = new PublicAPIsApi();
        Long id = 789; // Long | 
        try {
            apiInstance.deletePolicy2(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsApi#deletePolicy2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsApi;

public class PublicAPIsApiExample {

    public static void main(String[] args) {
        PublicAPIsApi apiInstance = new PublicAPIsApi();
        Long id = 789; // Long | 
        try {
            apiInstance.deletePolicy2(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsApi#deletePolicy2");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsApi()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new PublicAPIsApi();
            var id = 789;  // Long | 

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

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

$api_instance = new Swagger\Client\ApiPublicAPIsApi();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::PublicAPIsApi->new();
my $id = 789; # Long | 

eval { 
    $api_instance->deletePolicy2(id => $id);
};
if ($@) {
    warn "Exception when calling PublicAPIsApi->deletePolicy2: $@\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.PublicAPIsApi()
id = 789 # Long | 

try: 
    api_instance.delete_policy2(id)
except ApiException as e:
    print("Exception when calling PublicAPIsApi->deletePolicy2: %s\n" % e)

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

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

public class PublicAPIsApiExample {

    public static void main(String[] args) {
        
        PublicAPIsApi apiInstance = new PublicAPIsApi();
        Long id = 789; // Long | 
        try {
            apiInstance.deleteRepository(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsApi#deleteRepository");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsApi;

public class PublicAPIsApiExample {

    public static void main(String[] args) {
        PublicAPIsApi apiInstance = new PublicAPIsApi();
        Long id = 789; // Long | 
        try {
            apiInstance.deleteRepository(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsApi#deleteRepository");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsApi()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new PublicAPIsApi();
            var id = 789;  // Long | 

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

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

$api_instance = new Swagger\Client\ApiPublicAPIsApi();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::PublicAPIsApi->new();
my $id = 789; # Long | 

eval { 
    $api_instance->deleteRepository(id => $id);
};
if ($@) {
    warn "Exception when calling PublicAPIsApi->deleteRepository: $@\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.PublicAPIsApi()
id = 789 # Long | 

try: 
    api_instance.delete_repository(id)
except ApiException as e:
    print("Exception when calling PublicAPIsApi->deleteRepository: %s\n" % e)

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

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

public class PublicAPIsApiExample {

    public static void main(String[] args) {
        
        PublicAPIsApi apiInstance = new PublicAPIsApi();
        Long id = 789; // Long | 
        try {
            VXPolicy result = apiInstance.getPolicy2(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsApi#getPolicy2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsApi;

public class PublicAPIsApiExample {

    public static void main(String[] args) {
        PublicAPIsApi apiInstance = new PublicAPIsApi();
        Long id = 789; // Long | 
        try {
            VXPolicy result = apiInstance.getPolicy2(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsApi#getPolicy2");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsApi()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new PublicAPIsApi();
            var id = 789;  // Long | 

            try
            {
                VXPolicy result = apiInstance.getPolicy2(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsApi.getPolicy2: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiPublicAPIsApi();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::PublicAPIsApi->new();
my $id = 789; # Long | 

eval { 
    my $result = $api_instance->getPolicy2(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PublicAPIsApi->getPolicy2: $@\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.PublicAPIsApi()
id = 789 # Long | 

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

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

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

public class PublicAPIsApiExample {

    public static void main(String[] args) {
        
        PublicAPIsApi apiInstance = new PublicAPIsApi();
        Long id = 789; // Long | 
        try {
            VXRepository result = apiInstance.getRepository(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsApi#getRepository");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsApi;

public class PublicAPIsApiExample {

    public static void main(String[] args) {
        PublicAPIsApi apiInstance = new PublicAPIsApi();
        Long id = 789; // Long | 
        try {
            VXRepository result = apiInstance.getRepository(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsApi#getRepository");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsApi()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new PublicAPIsApi();
            var id = 789;  // Long | 

            try
            {
                VXRepository result = apiInstance.getRepository(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsApi.getRepository: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiPublicAPIsApi();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::PublicAPIsApi->new();
my $id = 789; # Long | 

eval { 
    my $result = $api_instance->getRepository(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PublicAPIsApi->getRepository: $@\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.PublicAPIsApi()
id = 789 # Long | 

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

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

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

public class PublicAPIsApiExample {

    public static void main(String[] args) {
        
        PublicAPIsApi apiInstance = new PublicAPIsApi();
        try {
            VXPolicyList result = apiInstance.searchPolicies();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsApi#searchPolicies");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsApi;

public class PublicAPIsApiExample {

    public static void main(String[] args) {
        PublicAPIsApi apiInstance = new PublicAPIsApi();
        try {
            VXPolicyList result = apiInstance.searchPolicies();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsApi#searchPolicies");
            e.printStackTrace();
        }
    }
}

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

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

var RangerRestApi = require('ranger_rest_api');

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

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

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

            var apiInstance = new PublicAPIsApi();

            try
            {
                VXPolicyList result = apiInstance.searchPolicies();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsApi.searchPolicies: " + e.Message );
            }
        }
    }
}

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

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

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

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

my $api_instance = WWW::SwaggerClient::PublicAPIsApi->new();

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

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

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

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

public class PublicAPIsApiExample {

    public static void main(String[] args) {
        
        PublicAPIsApi apiInstance = new PublicAPIsApi();
        try {
            VXRepositoryList result = apiInstance.searchRepositories();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsApi#searchRepositories");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsApi;

public class PublicAPIsApiExample {

    public static void main(String[] args) {
        PublicAPIsApi apiInstance = new PublicAPIsApi();
        try {
            VXRepositoryList result = apiInstance.searchRepositories();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsApi#searchRepositories");
            e.printStackTrace();
        }
    }
}

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

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

var RangerRestApi = require('ranger_rest_api');

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

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

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

            var apiInstance = new PublicAPIsApi();

            try
            {
                VXRepositoryList result = apiInstance.searchRepositories();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsApi.searchRepositories: " + e.Message );
            }
        }
    }
}

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

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

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

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

my $api_instance = WWW::SwaggerClient::PublicAPIsApi->new();

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

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

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

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

public class PublicAPIsApiExample {

    public static void main(String[] args) {
        
        PublicAPIsApi apiInstance = new PublicAPIsApi();
        Long id = 789; // Long | 
        VXPolicy body = ; // VXPolicy | 
        try {
            VXPolicy result = apiInstance.updatePolicy2(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsApi#updatePolicy2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsApi;

public class PublicAPIsApiExample {

    public static void main(String[] args) {
        PublicAPIsApi apiInstance = new PublicAPIsApi();
        Long id = 789; // Long | 
        VXPolicy body = ; // VXPolicy | 
        try {
            VXPolicy result = apiInstance.updatePolicy2(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsApi#updatePolicy2");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 
VXPolicy *body = ; //  (optional)

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsApi()
var id = 789; // {{Long}} 
var opts = { 
  'body':  // {{VXPolicy}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updatePolicy2(id, opts, callback);

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

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

            var apiInstance = new PublicAPIsApi();
            var id = 789;  // Long | 
            var body = new VXPolicy(); // VXPolicy |  (optional) 

            try
            {
                VXPolicy result = apiInstance.updatePolicy2(id, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsApi.updatePolicy2: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiPublicAPIsApi();
$id = 789; // Long | 
$body = ; // VXPolicy | 

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

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

my $api_instance = WWW::SwaggerClient::PublicAPIsApi->new();
my $id = 789; # Long | 
my $body = WWW::SwaggerClient::Object::VXPolicy->new(); # VXPolicy | 

eval { 
    my $result = $api_instance->updatePolicy2(id => $id, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PublicAPIsApi->updatePolicy2: $@\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.PublicAPIsApi()
id = 789 # Long | 
body =  # VXPolicy |  (optional)

try: 
    api_response = api_instance.update_policy2(id, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PublicAPIsApi->updatePolicy2: %s\n" % e)

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

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

public class PublicAPIsApiExample {

    public static void main(String[] args) {
        
        PublicAPIsApi apiInstance = new PublicAPIsApi();
        Long id = 789; // Long | 
        VXRepository body = ; // VXRepository | 
        try {
            VXRepository result = apiInstance.updateRepository(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsApi#updateRepository");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsApi;

public class PublicAPIsApiExample {

    public static void main(String[] args) {
        PublicAPIsApi apiInstance = new PublicAPIsApi();
        Long id = 789; // Long | 
        VXRepository body = ; // VXRepository | 
        try {
            VXRepository result = apiInstance.updateRepository(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsApi#updateRepository");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 
VXRepository *body = ; //  (optional)

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsApi()
var id = 789; // {{Long}} 
var opts = { 
  'body':  // {{VXRepository}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateRepository(id, opts, callback);

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

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

            var apiInstance = new PublicAPIsApi();
            var id = 789;  // Long | 
            var body = new VXRepository(); // VXRepository |  (optional) 

            try
            {
                VXRepository result = apiInstance.updateRepository(id, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsApi.updateRepository: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiPublicAPIsApi();
$id = 789; // Long | 
$body = ; // VXRepository | 

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

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

my $api_instance = WWW::SwaggerClient::PublicAPIsApi->new();
my $id = 789; # Long | 
my $body = WWW::SwaggerClient::Object::VXRepository->new(); # VXRepository | 

eval { 
    my $result = $api_instance->updateRepository(id => $id, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PublicAPIsApi->updateRepository: $@\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.PublicAPIsApi()
id = 789 # Long | 
body =  # VXRepository |  (optional)

try: 
    api_response = api_instance.update_repository(id, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PublicAPIsApi->updateRepository: %s\n" % e)

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

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

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Long id = 789; // Long | 
        Boolean body = ; // Boolean | 
        try {
            RangerRole result = apiInstance.addUsersAndGroups(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#addUsersAndGroups");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Long id = 789; // Long | 
        Boolean body = ; // Boolean | 
        try {
            RangerRole result = apiInstance.addUsersAndGroups(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#addUsersAndGroups");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 
Boolean *body = ; //  (optional)

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var id = 789; // {{Long}} 
var opts = { 
  'body':  // {{Boolean}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addUsersAndGroups(id, opts, callback);

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

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

            var apiInstance = new PublicAPIsv2Api();
            var id = 789;  // Long | 
            var body = new Boolean(); // Boolean |  (optional) 

            try
            {
                RangerRole result = apiInstance.addUsersAndGroups(id, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.addUsersAndGroups: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$id = 789; // Long | 
$body = ; // Boolean | 

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

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

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $id = 789; # Long | 
my $body = WWW::SwaggerClient::Object::Boolean->new(); # Boolean | 

eval { 
    my $result = $api_instance->addUsersAndGroups(id => $id, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->addUsersAndGroups: $@\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.PublicAPIsv2Api()
id = 789 # Long | 
body =  # Boolean |  (optional)

try: 
    api_response = api_instance.add_users_and_groups(id, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->addUsersAndGroups: %s\n" % e)

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

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

public class PublicAPIsv2ApiExample {

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

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

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

RangerPolicy *body = ; //  (optional)

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var opts = { 
  'body':  // {{RangerPolicy}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.applyPolicy2(opts, callback);

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

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

            var apiInstance = new PublicAPIsv2Api();
            var body = new RangerPolicy(); // RangerPolicy |  (optional) 

            try
            {
                RangerPolicy result = apiInstance.applyPolicy2(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.applyPolicy2: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$body = ; // RangerPolicy | 

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

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

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

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

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

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

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

public class PublicAPIsv2ApiExample {

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

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

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

RangerPolicy *body = ; //  (optional)

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var opts = { 
  'body':  // {{RangerPolicy}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createPolicy3(opts, callback);

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

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

            var apiInstance = new PublicAPIsv2Api();
            var body = new RangerPolicy(); // RangerPolicy |  (optional) 

            try
            {
                RangerPolicy result = apiInstance.createPolicy3(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.createPolicy3: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$body = ; // RangerPolicy | 

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

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

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

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

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

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

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

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        RangerRole body = ; // RangerRole | 
        Boolean createNonExistUserGroup = true; // Boolean | 
        String serviceName = serviceName_example; // String | 
        try {
            RangerRole result = apiInstance.createRole(body, createNonExistUserGroup, serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#createRole");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        RangerRole body = ; // RangerRole | 
        Boolean createNonExistUserGroup = true; // Boolean | 
        String serviceName = serviceName_example; // String | 
        try {
            RangerRole result = apiInstance.createRole(body, createNonExistUserGroup, serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#createRole");
            e.printStackTrace();
        }
    }
}

RangerRole *body = ; //  (optional)
Boolean *createNonExistUserGroup = true; //  (optional) (default to false)
String *serviceName = serviceName_example; //  (optional)

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

[apiInstance createRoleWith:body
    createNonExistUserGroup:createNonExistUserGroup
    serviceName:serviceName
              completionHandler: ^(RangerRole output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var opts = { 
  'body':  // {{RangerRole}} 
  'createNonExistUserGroup': true // {{Boolean}} 
  'serviceName': serviceName_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createRole(opts, callback);

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

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

            var apiInstance = new PublicAPIsv2Api();
            var body = new RangerRole(); // RangerRole |  (optional) 
            var createNonExistUserGroup = true;  // Boolean |  (optional)  (default to false)
            var serviceName = serviceName_example;  // String |  (optional) 

            try
            {
                RangerRole result = apiInstance.createRole(body, createNonExistUserGroup, serviceName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.createRole: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$body = ; // RangerRole | 
$createNonExistUserGroup = true; // Boolean | 
$serviceName = serviceName_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $body = WWW::SwaggerClient::Object::RangerRole->new(); # RangerRole | 
my $createNonExistUserGroup = true; # Boolean | 
my $serviceName = serviceName_example; # String | 

eval { 
    my $result = $api_instance->createRole(body => $body, createNonExistUserGroup => $createNonExistUserGroup, serviceName => $serviceName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->createRole: $@\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.PublicAPIsv2Api()
body =  # RangerRole |  (optional)
createNonExistUserGroup = true # Boolean |  (optional) (default to false)
serviceName = serviceName_example # String |  (optional)

try: 
    api_response = api_instance.create_role(body=body, createNonExistUserGroup=createNonExistUserGroup, serviceName=serviceName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->createRole: %s\n" % e)

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

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

public class PublicAPIsv2ApiExample {

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

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

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

RangerSecurityZone *body = ; //  (optional)

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var opts = { 
  'body':  // {{RangerSecurityZone}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createSecurityZone(opts, callback);

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

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

            var apiInstance = new PublicAPIsv2Api();
            var body = new RangerSecurityZone(); // RangerSecurityZone |  (optional) 

            try
            {
                RangerSecurityZone result = apiInstance.createSecurityZone(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.createSecurityZone: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$body = ; // RangerSecurityZone | 

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

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

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

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

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

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

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

public class PublicAPIsv2ApiExample {

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

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

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

RangerService *body = ; //  (optional)

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var opts = { 
  'body':  // {{RangerService}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createService2(opts, callback);

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

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

            var apiInstance = new PublicAPIsv2Api();
            var body = new RangerService(); // RangerService |  (optional) 

            try
            {
                RangerService result = apiInstance.createService2(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.createService2: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$body = ; // RangerService | 

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

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

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

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

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

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

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

public class PublicAPIsv2ApiExample {

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

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

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

RangerServiceDef *body = ; //  (optional)

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var opts = { 
  'body':  // {{RangerServiceDef}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createServiceDef2(opts, callback);

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

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

            var apiInstance = new PublicAPIsv2Api();
            var body = new RangerServiceDef(); // RangerServiceDef |  (optional) 

            try
            {
                RangerServiceDef result = apiInstance.createServiceDef2(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.createServiceDef2: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$body = ; // RangerServiceDef | 

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

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

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

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

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

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

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

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Long id = 789; // Long | 
        try {
            apiInstance.deletePolicy3(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#deletePolicy3");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Long id = 789; // Long | 
        try {
            apiInstance.deletePolicy3(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#deletePolicy3");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new PublicAPIsv2Api();
            var id = 789;  // Long | 

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

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

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $id = 789; # Long | 

eval { 
    $api_instance->deletePolicy3(id => $id);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->deletePolicy3: $@\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.PublicAPIsv2Api()
id = 789 # Long | 

try: 
    api_instance.delete_policy3(id)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->deletePolicy3: %s\n" % e)

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

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

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String guid = guid_example; // String | 
        String serviceName = serviceName_example; // String | 
        String zoneName = zoneName_example; // String | 
        try {
            apiInstance.deletePolicyByGUIDAndServiceNameAndZoneName2(guid, serviceName, zoneName);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#deletePolicyByGUIDAndServiceNameAndZoneName2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String guid = guid_example; // String | 
        String serviceName = serviceName_example; // String | 
        String zoneName = zoneName_example; // String | 
        try {
            apiInstance.deletePolicyByGUIDAndServiceNameAndZoneName2(guid, serviceName, zoneName);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#deletePolicyByGUIDAndServiceNameAndZoneName2");
            e.printStackTrace();
        }
    }
}

String *guid = guid_example; // 
String *serviceName = serviceName_example; //  (optional)
String *zoneName = zoneName_example; //  (optional)

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var guid = guid_example; // {{String}} 
var opts = { 
  'serviceName': serviceName_example, // {{String}} 
  'zoneName': zoneName_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deletePolicyByGUIDAndServiceNameAndZoneName2(guid, opts, callback);

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

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

            var apiInstance = new PublicAPIsv2Api();
            var guid = guid_example;  // String | 
            var serviceName = serviceName_example;  // String |  (optional) 
            var zoneName = zoneName_example;  // String |  (optional) 

            try
            {
                apiInstance.deletePolicyByGUIDAndServiceNameAndZoneName2(guid, serviceName, zoneName);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.deletePolicyByGUIDAndServiceNameAndZoneName2: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$guid = guid_example; // String | 
$serviceName = serviceName_example; // String | 
$zoneName = zoneName_example; // String | 

try {
    $api_instance->deletePolicyByGUIDAndServiceNameAndZoneName2($guid, $serviceName, $zoneName);
} catch (Exception $e) {
    echo 'Exception when calling PublicAPIsv2Api->deletePolicyByGUIDAndServiceNameAndZoneName2: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $guid = guid_example; # String | 
my $serviceName = serviceName_example; # String | 
my $zoneName = zoneName_example; # String | 

eval { 
    $api_instance->deletePolicyByGUIDAndServiceNameAndZoneName2(guid => $guid, serviceName => $serviceName, zoneName => $zoneName);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->deletePolicyByGUIDAndServiceNameAndZoneName2: $@\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.PublicAPIsv2Api()
guid = guid_example # String | 
serviceName = serviceName_example # String |  (optional)
zoneName = zoneName_example # String |  (optional)

try: 
    api_instance.delete_policy_by_guid_and_service_name_and_zone_name2(guid, serviceName=serviceName, zoneName=zoneName)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->deletePolicyByGUIDAndServiceNameAndZoneName2: %s\n" % e)

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

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

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String policyname = policyname_example; // String | 
        String servicename = servicename_example; // String | 
        String zoneName = zoneName_example; // String | 
        try {
            apiInstance.deletePolicyByName(policyname, servicename, zoneName);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#deletePolicyByName");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String policyname = policyname_example; // String | 
        String servicename = servicename_example; // String | 
        String zoneName = zoneName_example; // String | 
        try {
            apiInstance.deletePolicyByName(policyname, servicename, zoneName);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#deletePolicyByName");
            e.printStackTrace();
        }
    }
}

String *policyname = policyname_example; //  (optional)
String *servicename = servicename_example; //  (optional)
String *zoneName = zoneName_example; //  (optional)

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

[apiInstance deletePolicyByNameWith:policyname
    servicename:servicename
    zoneName:zoneName
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var opts = { 
  'policyname': policyname_example, // {{String}} 
  'servicename': servicename_example, // {{String}} 
  'zoneName': zoneName_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deletePolicyByName(opts, callback);

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

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

            var apiInstance = new PublicAPIsv2Api();
            var policyname = policyname_example;  // String |  (optional) 
            var servicename = servicename_example;  // String |  (optional) 
            var zoneName = zoneName_example;  // String |  (optional) 

            try
            {
                apiInstance.deletePolicyByName(policyname, servicename, zoneName);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.deletePolicyByName: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$policyname = policyname_example; // String | 
$servicename = servicename_example; // String | 
$zoneName = zoneName_example; // String | 

try {
    $api_instance->deletePolicyByName($policyname, $servicename, $zoneName);
} catch (Exception $e) {
    echo 'Exception when calling PublicAPIsv2Api->deletePolicyByName: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $policyname = policyname_example; # String | 
my $servicename = servicename_example; # String | 
my $zoneName = zoneName_example; # String | 

eval { 
    $api_instance->deletePolicyByName(policyname => $policyname, servicename => $servicename, zoneName => $zoneName);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->deletePolicyByName: $@\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.PublicAPIsv2Api()
policyname = policyname_example # String |  (optional)
servicename = servicename_example # String |  (optional)
zoneName = zoneName_example # String |  (optional)

try: 
    api_instance.delete_policy_by_name(policyname=policyname, servicename=servicename, zoneName=zoneName)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->deletePolicyByName: %s\n" % e)

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

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

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Integer days = 56; // Integer | 
        try {
            apiInstance.deletePolicyDeltas2(days);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#deletePolicyDeltas2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Integer days = 56; // Integer | 
        try {
            apiInstance.deletePolicyDeltas2(days);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#deletePolicyDeltas2");
            e.printStackTrace();
        }
    }
}

Integer *days = 56; //  (optional) (default to 7)

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var opts = { 
  'days': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deletePolicyDeltas2(opts, callback);

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

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

            var apiInstance = new PublicAPIsv2Api();
            var days = 56;  // Integer |  (optional)  (default to 7)

            try
            {
                apiInstance.deletePolicyDeltas2(days);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.deletePolicyDeltas2: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$days = 56; // Integer | 

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

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

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $days = 56; # Integer | 

eval { 
    $api_instance->deletePolicyDeltas2(days => $days);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->deletePolicyDeltas2: $@\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.PublicAPIsv2Api()
days = 56 # Integer |  (optional) (default to 7)

try: 
    api_instance.delete_policy_deltas2(days=days)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->deletePolicyDeltas2: %s\n" % e)

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

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

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String name = name_example; // String | 
        String execUser = execUser_example; // String | 
        String serviceName = serviceName_example; // String | 
        try {
            apiInstance.deleteRole(name, execUser, serviceName);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#deleteRole");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String name = name_example; // String | 
        String execUser = execUser_example; // String | 
        String serviceName = serviceName_example; // String | 
        try {
            apiInstance.deleteRole(name, execUser, serviceName);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#deleteRole");
            e.printStackTrace();
        }
    }
}

String *name = name_example; // 
String *execUser = execUser_example; //  (optional)
String *serviceName = serviceName_example; //  (optional)

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

[apiInstance deleteRoleWith:name
    execUser:execUser
    serviceName:serviceName
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var name = name_example; // {{String}} 
var opts = { 
  'execUser': execUser_example, // {{String}} 
  'serviceName': serviceName_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteRole(name, opts, callback);

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

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

            var apiInstance = new PublicAPIsv2Api();
            var name = name_example;  // String | 
            var execUser = execUser_example;  // String |  (optional) 
            var serviceName = serviceName_example;  // String |  (optional) 

            try
            {
                apiInstance.deleteRole(name, execUser, serviceName);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.deleteRole: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$name = name_example; // String | 
$execUser = execUser_example; // String | 
$serviceName = serviceName_example; // String | 

try {
    $api_instance->deleteRole($name, $execUser, $serviceName);
} catch (Exception $e) {
    echo 'Exception when calling PublicAPIsv2Api->deleteRole: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $name = name_example; # String | 
my $execUser = execUser_example; # String | 
my $serviceName = serviceName_example; # String | 

eval { 
    $api_instance->deleteRole(name => $name, execUser => $execUser, serviceName => $serviceName);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->deleteRole: $@\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.PublicAPIsv2Api()
name = name_example # String | 
execUser = execUser_example # String |  (optional)
serviceName = serviceName_example # String |  (optional)

try: 
    api_instance.delete_role(name, execUser=execUser, serviceName=serviceName)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->deleteRole: %s\n" % e)

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

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

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Long id = 789; // Long | 
        try {
            apiInstance.deleteRole_0(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#deleteRole_0");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Long id = 789; // Long | 
        try {
            apiInstance.deleteRole_0(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#deleteRole_0");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new PublicAPIsv2Api();
            var id = 789;  // Long | 

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

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

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $id = 789; # Long | 

eval { 
    $api_instance->deleteRole_0(id => $id);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->deleteRole_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.PublicAPIsv2Api()
id = 789 # Long | 

try: 
    api_instance.delete_role_0(id)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->deleteRole_0: %s\n" % e)

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

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

public class PublicAPIsv2ApiExample {

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

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

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

String *name = name_example; // 

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var name = name_example; // {{String}} 

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

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

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

            var apiInstance = new PublicAPIsv2Api();
            var name = name_example;  // String | 

            try
            {
                apiInstance.deleteSecurityZone(name);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.deleteSecurityZone: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$name = name_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $name = name_example; # String | 

eval { 
    $api_instance->deleteSecurityZone(name => $name);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->deleteSecurityZone: $@\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.PublicAPIsv2Api()
name = name_example # String | 

try: 
    api_instance.delete_security_zone(name)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->deleteSecurityZone: %s\n" % e)

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

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

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Long id = 789; // Long | 
        try {
            apiInstance.deleteSecurityZone_0(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#deleteSecurityZone_0");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Long id = 789; // Long | 
        try {
            apiInstance.deleteSecurityZone_0(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#deleteSecurityZone_0");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new PublicAPIsv2Api();
            var id = 789;  // Long | 

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

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

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $id = 789; # Long | 

eval { 
    $api_instance->deleteSecurityZone_0(id => $id);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->deleteSecurityZone_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.PublicAPIsv2Api()
id = 789 # Long | 

try: 
    api_instance.delete_security_zone_0(id)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->deleteSecurityZone_0: %s\n" % e)

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

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

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Long id = 789; // Long | 
        try {
            apiInstance.deleteService2(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#deleteService2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Long id = 789; // Long | 
        try {
            apiInstance.deleteService2(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#deleteService2");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new PublicAPIsv2Api();
            var id = 789;  // Long | 

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

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

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $id = 789; # Long | 

eval { 
    $api_instance->deleteService2(id => $id);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->deleteService2: $@\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.PublicAPIsv2Api()
id = 789 # Long | 

try: 
    api_instance.delete_service2(id)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->deleteService2: %s\n" % e)

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

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

public class PublicAPIsv2ApiExample {

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

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

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

String *name = name_example; // 

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var name = name_example; // {{String}} 

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

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

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

            var apiInstance = new PublicAPIsv2Api();
            var name = name_example;  // String | 

            try
            {
                apiInstance.deleteServiceByName(name);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.deleteServiceByName: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$name = name_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $name = name_example; # String | 

eval { 
    $api_instance->deleteServiceByName(name => $name);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->deleteServiceByName: $@\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.PublicAPIsv2Api()
name = name_example # String | 

try: 
    api_instance.delete_service_by_name(name)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->deleteServiceByName: %s\n" % e)

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

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

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Long id = 789; // Long | 
        try {
            apiInstance.deleteServiceDef2(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#deleteServiceDef2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Long id = 789; // Long | 
        try {
            apiInstance.deleteServiceDef2(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#deleteServiceDef2");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var id = 789; // {{Long}} 

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

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

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

            var apiInstance = new PublicAPIsv2Api();
            var id = 789;  // Long | 

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

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

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$id = 789; // Long | 

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

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

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $id = 789; # Long | 

eval { 
    $api_instance->deleteServiceDef2(id => $id);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->deleteServiceDef2: $@\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.PublicAPIsv2Api()
id = 789 # Long | 

try: 
    api_instance.delete_service_def2(id)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->deleteServiceDef2: %s\n" % e)

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

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

public class PublicAPIsv2ApiExample {

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

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

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

String *name = name_example; // 

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var name = name_example; // {{String}} 

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

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

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

            var apiInstance = new PublicAPIsv2Api();
            var name = name_example;  // String | 

            try
            {
                apiInstance.deleteServiceDefByName(name);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.deleteServiceDefByName: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$name = name_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $name = name_example; # String | 

eval { 
    $api_instance->deleteServiceDefByName(name => $name);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->deleteServiceDefByName: $@\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.PublicAPIsv2Api()
name = name_example # String | 

try: 
    api_instance.delete_service_def_by_name(name)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->deleteServiceDefByName: %s\n" % e)

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

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

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Integer days = 56; // Integer | 
        try {
            apiInstance.deleteTagDeltas(days);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#deleteTagDeltas");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Integer days = 56; // Integer | 
        try {
            apiInstance.deleteTagDeltas(days);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#deleteTagDeltas");
            e.printStackTrace();
        }
    }
}

Integer *days = 56; //  (optional) (default to 7)

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var opts = { 
  'days': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteTagDeltas(opts, callback);

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

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

            var apiInstance = new PublicAPIsv2Api();
            var days = 56;  // Integer |  (optional)  (default to 7)

            try
            {
                apiInstance.deleteTagDeltas(days);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.deleteTagDeltas: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$days = 56; // Integer | 

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

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

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $days = 56; # Integer | 

eval { 
    $api_instance->deleteTagDeltas(days => $days);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->deleteTagDeltas: $@\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.PublicAPIsv2Api()
days = 56 # Integer |  (optional) (default to 7)

try: 
    api_instance.delete_tag_deltas(days=days)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->deleteTagDeltas: %s\n" % e)

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

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

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String execUser = execUser_example; // String | 
        String serviceName = serviceName_example; // String | 
        try {
            array['String'] result = apiInstance.getAllRoleNames(execUser, serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getAllRoleNames");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String execUser = execUser_example; // String | 
        String serviceName = serviceName_example; // String | 
        try {
            array['String'] result = apiInstance.getAllRoleNames(execUser, serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getAllRoleNames");
            e.printStackTrace();
        }
    }
}

String *execUser = execUser_example; //  (optional)
String *serviceName = serviceName_example; //  (optional)

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

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

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var opts = { 
  'execUser': execUser_example, // {{String}} 
  'serviceName': serviceName_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAllRoleNames(opts, callback);

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

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

            var apiInstance = new PublicAPIsv2Api();
            var execUser = execUser_example;  // String |  (optional) 
            var serviceName = serviceName_example;  // String |  (optional) 

            try
            {
                array['String'] result = apiInstance.getAllRoleNames(execUser, serviceName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.getAllRoleNames: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$execUser = execUser_example; // String | 
$serviceName = serviceName_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $execUser = execUser_example; # String | 
my $serviceName = serviceName_example; # String | 

eval { 
    my $result = $api_instance->getAllRoleNames(execUser => $execUser, serviceName => $serviceName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->getAllRoleNames: $@\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.PublicAPIsv2Api()
execUser = execUser_example # String |  (optional)
serviceName = serviceName_example # String |  (optional)

try: 
    api_response = api_instance.get_all_role_names(execUser=execUser, serviceName=serviceName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->getAllRoleNames: %s\n" % e)

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

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

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        try {
            array[RangerRole] result = apiInstance.getAllRoles();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getAllRoles");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        try {
            array[RangerRole] result = apiInstance.getAllRoles();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getAllRoles");
            e.printStackTrace();
        }
    }
}

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

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

var RangerRestApi = require('ranger_rest_api');

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

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

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

            var apiInstance = new PublicAPIsv2Api();

            try
            {
                array[RangerRole] result = apiInstance.getAllRoles();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.getAllRoles: " + e.Message );
            }
        }
    }
}

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

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

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

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

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();

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

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

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

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

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        try {
            array[RangerSecurityZone] result = apiInstance.getAllZones();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getAllZones");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        try {
            array[RangerSecurityZone] result = apiInstance.getAllZones();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getAllZones");
            e.printStackTrace();
        }
    }
}

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

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

var RangerRestApi = require('ranger_rest_api');

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

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

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

            var apiInstance = new PublicAPIsv2Api();

            try
            {
                array[RangerSecurityZone] result = apiInstance.getAllZones();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.getAllZones: " + e.Message );
            }
        }
    }
}

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

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

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

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

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();

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

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

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

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

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        try {
            array[RangerPluginInfo] result = apiInstance.getPluginsInfo2();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getPluginsInfo2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        try {
            array[RangerPluginInfo] result = apiInstance.getPluginsInfo2();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getPluginsInfo2");
            e.printStackTrace();
        }
    }
}

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

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

var RangerRestApi = require('ranger_rest_api');

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

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

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

            var apiInstance = new PublicAPIsv2Api();

            try
            {
                array[RangerPluginInfo] result = apiInstance.getPluginsInfo2();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.getPluginsInfo2: " + e.Message );
            }
        }
    }
}

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

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

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

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

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();

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

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

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

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

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        try {
            array[RangerPolicy] result = apiInstance.getPolicies2();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getPolicies2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        try {
            array[RangerPolicy] result = apiInstance.getPolicies2();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getPolicies2");
            e.printStackTrace();
        }
    }
}

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

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

var RangerRestApi = require('ranger_rest_api');

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

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

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

            var apiInstance = new PublicAPIsv2Api();

            try
            {
                array[RangerPolicy] result = apiInstance.getPolicies2();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.getPolicies2: " + e.Message );
            }
        }
    }
}

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

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

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

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

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();

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

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

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

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

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String serviceDefName = serviceDefName_example; // String | 
        String serviceName = serviceName_example; // String | 
        try {
            array[RangerPolicy] result = apiInstance.getPoliciesForResource2(serviceDefName, serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getPoliciesForResource2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String serviceDefName = serviceDefName_example; // String | 
        String serviceName = serviceName_example; // String | 
        try {
            array[RangerPolicy] result = apiInstance.getPoliciesForResource2(serviceDefName, serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getPoliciesForResource2");
            e.printStackTrace();
        }
    }
}

String *serviceDefName = serviceDefName_example; // 
String *serviceName = serviceName_example; //  (optional)

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

[apiInstance getPoliciesForResource2With:serviceDefName
    serviceName:serviceName
              completionHandler: ^(array[RangerPolicy] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var serviceDefName = serviceDefName_example; // {{String}} 
var opts = { 
  'serviceName': serviceName_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getPoliciesForResource2(serviceDefName, opts, callback);

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

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

            var apiInstance = new PublicAPIsv2Api();
            var serviceDefName = serviceDefName_example;  // String | 
            var serviceName = serviceName_example;  // String |  (optional) 

            try
            {
                array[RangerPolicy] result = apiInstance.getPoliciesForResource2(serviceDefName, serviceName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.getPoliciesForResource2: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$serviceDefName = serviceDefName_example; // String | 
$serviceName = serviceName_example; // String | 

try {
    $result = $api_instance->getPoliciesForResource2($serviceDefName, $serviceName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PublicAPIsv2Api->getPoliciesForResource2: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PublicAPIsv2Api;

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $serviceDefName = serviceDefName_example; # String | 
my $serviceName = serviceName_example; # String | 

eval { 
    my $result = $api_instance->getPoliciesForResource2(serviceDefName => $serviceDefName, serviceName => $serviceName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->getPoliciesForResource2: $@\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.PublicAPIsv2Api()
serviceDefName = serviceDefName_example # String | 
serviceName = serviceName_example # String |  (optional)

try: 
    api_response = api_instance.get_policies_for_resource2(serviceDefName, serviceName=serviceName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->getPoliciesForResource2: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PublicAPIsv2Api;

import java.io.File;
import java.util.*;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Long id = 789; // Long | 
        try {
            RangerPolicy result = apiInstance.getPolicy3(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getPolicy3");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Long id = 789; // Long | 
        try {
            RangerPolicy result = apiInstance.getPolicy3(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getPolicy3");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

PublicAPIsv2Api *apiInstance = [[PublicAPIsv2Api alloc] init];

[apiInstance getPolicy3With:id
              completionHandler: ^(RangerPolicy output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var id = 789; // {{Long}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getPolicy3(id, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getPolicy3Example
    {
        public void main()
        {

            var apiInstance = new PublicAPIsv2Api();
            var id = 789;  // Long | 

            try
            {
                RangerPolicy result = apiInstance.getPolicy3(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.getPolicy3: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$id = 789; // Long | 

try {
    $result = $api_instance->getPolicy3($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PublicAPIsv2Api->getPolicy3: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PublicAPIsv2Api;

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $id = 789; # Long | 

eval { 
    my $result = $api_instance->getPolicy3(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->getPolicy3: $@\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.PublicAPIsv2Api()
id = 789 # Long | 

try: 
    api_response = api_instance.get_policy3(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->getPolicy3: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PublicAPIsv2Api;

import java.io.File;
import java.util.*;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String guid = guid_example; // String | 
        String zoneName = zoneName_example; // String | 
        String serviceName = serviceName_example; // String | 
        try {
            RangerPolicy result = apiInstance.getPolicyByGUIDAndServiceNameAndZoneName2(guid, zoneName, serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getPolicyByGUIDAndServiceNameAndZoneName2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String guid = guid_example; // String | 
        String zoneName = zoneName_example; // String | 
        String serviceName = serviceName_example; // String | 
        try {
            RangerPolicy result = apiInstance.getPolicyByGUIDAndServiceNameAndZoneName2(guid, zoneName, serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getPolicyByGUIDAndServiceNameAndZoneName2");
            e.printStackTrace();
        }
    }
}

String *guid = guid_example; // 
String *zoneName = zoneName_example; //  (optional)
String *serviceName = serviceName_example; //  (optional)

PublicAPIsv2Api *apiInstance = [[PublicAPIsv2Api alloc] init];

[apiInstance getPolicyByGUIDAndServiceNameAndZoneName2With:guid
    zoneName:zoneName
    serviceName:serviceName
              completionHandler: ^(RangerPolicy output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var guid = guid_example; // {{String}} 
var opts = { 
  'zoneName': zoneName_example, // {{String}} 
  'serviceName': serviceName_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getPolicyByGUIDAndServiceNameAndZoneName2(guid, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getPolicyByGUIDAndServiceNameAndZoneName2Example
    {
        public void main()
        {

            var apiInstance = new PublicAPIsv2Api();
            var guid = guid_example;  // String | 
            var zoneName = zoneName_example;  // String |  (optional) 
            var serviceName = serviceName_example;  // String |  (optional) 

            try
            {
                RangerPolicy result = apiInstance.getPolicyByGUIDAndServiceNameAndZoneName2(guid, zoneName, serviceName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.getPolicyByGUIDAndServiceNameAndZoneName2: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$guid = guid_example; // String | 
$zoneName = zoneName_example; // String | 
$serviceName = serviceName_example; // String | 

try {
    $result = $api_instance->getPolicyByGUIDAndServiceNameAndZoneName2($guid, $zoneName, $serviceName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PublicAPIsv2Api->getPolicyByGUIDAndServiceNameAndZoneName2: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PublicAPIsv2Api;

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $guid = guid_example; # String | 
my $zoneName = zoneName_example; # String | 
my $serviceName = serviceName_example; # String | 

eval { 
    my $result = $api_instance->getPolicyByGUIDAndServiceNameAndZoneName2(guid => $guid, zoneName => $zoneName, serviceName => $serviceName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->getPolicyByGUIDAndServiceNameAndZoneName2: $@\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.PublicAPIsv2Api()
guid = guid_example # String | 
zoneName = zoneName_example # String |  (optional)
serviceName = serviceName_example # String |  (optional)

try: 
    api_response = api_instance.get_policy_by_guid_and_service_name_and_zone_name2(guid, zoneName=zoneName, serviceName=serviceName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->getPolicyByGUIDAndServiceNameAndZoneName2: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PublicAPIsv2Api;

import java.io.File;
import java.util.*;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String policyname = policyname_example; // String | 
        String servicename = servicename_example; // String | 
        String zoneName = zoneName_example; // String | 
        try {
            RangerPolicy result = apiInstance.getPolicyByName(policyname, servicename, zoneName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getPolicyByName");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String policyname = policyname_example; // String | 
        String servicename = servicename_example; // String | 
        String zoneName = zoneName_example; // String | 
        try {
            RangerPolicy result = apiInstance.getPolicyByName(policyname, servicename, zoneName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getPolicyByName");
            e.printStackTrace();
        }
    }
}

String *policyname = policyname_example; // 
String *servicename = servicename_example; // 
String *zoneName = zoneName_example; //  (optional)

PublicAPIsv2Api *apiInstance = [[PublicAPIsv2Api alloc] init];

[apiInstance getPolicyByNameWith:policyname
    servicename:servicename
    zoneName:zoneName
              completionHandler: ^(RangerPolicy output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var policyname = policyname_example; // {{String}} 
var servicename = servicename_example; // {{String}} 
var opts = { 
  'zoneName': zoneName_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getPolicyByName(policyname, servicename, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getPolicyByNameExample
    {
        public void main()
        {

            var apiInstance = new PublicAPIsv2Api();
            var policyname = policyname_example;  // String | 
            var servicename = servicename_example;  // String | 
            var zoneName = zoneName_example;  // String |  (optional) 

            try
            {
                RangerPolicy result = apiInstance.getPolicyByName(policyname, servicename, zoneName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.getPolicyByName: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$policyname = policyname_example; // String | 
$servicename = servicename_example; // String | 
$zoneName = zoneName_example; // String | 

try {
    $result = $api_instance->getPolicyByName($policyname, $servicename, $zoneName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PublicAPIsv2Api->getPolicyByName: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PublicAPIsv2Api;

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $policyname = policyname_example; # String | 
my $servicename = servicename_example; # String | 
my $zoneName = zoneName_example; # String | 

eval { 
    my $result = $api_instance->getPolicyByName(policyname => $policyname, servicename => $servicename, zoneName => $zoneName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->getPolicyByName: $@\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.PublicAPIsv2Api()
policyname = policyname_example # String | 
servicename = servicename_example # String | 
zoneName = zoneName_example # String |  (optional)

try: 
    api_response = api_instance.get_policy_by_name(policyname, servicename, zoneName=zoneName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->getPolicyByName: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PublicAPIsv2Api;

import java.io.File;
import java.util.*;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String name = name_example; // String | 
        String execUser = execUser_example; // String | 
        String serviceName = serviceName_example; // String | 
        try {
            RangerRole result = apiInstance.getRole(name, execUser, serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getRole");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String name = name_example; // String | 
        String execUser = execUser_example; // String | 
        String serviceName = serviceName_example; // String | 
        try {
            RangerRole result = apiInstance.getRole(name, execUser, serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getRole");
            e.printStackTrace();
        }
    }
}

String *name = name_example; // 
String *execUser = execUser_example; //  (optional)
String *serviceName = serviceName_example; //  (optional)

PublicAPIsv2Api *apiInstance = [[PublicAPIsv2Api alloc] init];

[apiInstance getRoleWith:name
    execUser:execUser
    serviceName:serviceName
              completionHandler: ^(RangerRole output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var name = name_example; // {{String}} 
var opts = { 
  'execUser': execUser_example, // {{String}} 
  'serviceName': serviceName_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getRole(name, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getRoleExample
    {
        public void main()
        {

            var apiInstance = new PublicAPIsv2Api();
            var name = name_example;  // String | 
            var execUser = execUser_example;  // String |  (optional) 
            var serviceName = serviceName_example;  // String |  (optional) 

            try
            {
                RangerRole result = apiInstance.getRole(name, execUser, serviceName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.getRole: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$name = name_example; // String | 
$execUser = execUser_example; // String | 
$serviceName = serviceName_example; // String | 

try {
    $result = $api_instance->getRole($name, $execUser, $serviceName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PublicAPIsv2Api->getRole: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PublicAPIsv2Api;

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $name = name_example; # String | 
my $execUser = execUser_example; # String | 
my $serviceName = serviceName_example; # String | 

eval { 
    my $result = $api_instance->getRole(name => $name, execUser => $execUser, serviceName => $serviceName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->getRole: $@\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.PublicAPIsv2Api()
name = name_example # String | 
execUser = execUser_example # String |  (optional)
serviceName = serviceName_example # String |  (optional)

try: 
    api_response = api_instance.get_role(name, execUser=execUser, serviceName=serviceName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->getRole: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PublicAPIsv2Api;

import java.io.File;
import java.util.*;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Long id = 789; // Long | 
        try {
            RangerRole result = apiInstance.getRole_0(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getRole_0");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Long id = 789; // Long | 
        try {
            RangerRole result = apiInstance.getRole_0(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getRole_0");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

PublicAPIsv2Api *apiInstance = [[PublicAPIsv2Api alloc] init];

[apiInstance getRole_3With:id
              completionHandler: ^(RangerRole output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var id = 789; // {{Long}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getRole_0(id, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getRole_0Example
    {
        public void main()
        {

            var apiInstance = new PublicAPIsv2Api();
            var id = 789;  // Long | 

            try
            {
                RangerRole result = apiInstance.getRole_0(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.getRole_0: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$id = 789; // Long | 

try {
    $result = $api_instance->getRole_0($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PublicAPIsv2Api->getRole_0: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PublicAPIsv2Api;

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $id = 789; # Long | 

eval { 
    my $result = $api_instance->getRole_0(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->getRole_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.PublicAPIsv2Api()
id = 789 # Long | 

try: 
    api_response = api_instance.get_role_0(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->getRole_0: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PublicAPIsv2Api;

import java.io.File;
import java.util.*;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String name = name_example; // String | 
        try {
            RangerSecurityZone result = apiInstance.getSecurityZone(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getSecurityZone");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String name = name_example; // String | 
        try {
            RangerSecurityZone result = apiInstance.getSecurityZone(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getSecurityZone");
            e.printStackTrace();
        }
    }
}

String *name = name_example; // 

PublicAPIsv2Api *apiInstance = [[PublicAPIsv2Api alloc] init];

[apiInstance getSecurityZoneWith:name
              completionHandler: ^(RangerSecurityZone output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var 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.getSecurityZone(name, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getSecurityZoneExample
    {
        public void main()
        {

            var apiInstance = new PublicAPIsv2Api();
            var name = name_example;  // String | 

            try
            {
                RangerSecurityZone result = apiInstance.getSecurityZone(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.getSecurityZone: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$name = name_example; // String | 

try {
    $result = $api_instance->getSecurityZone($name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PublicAPIsv2Api->getSecurityZone: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PublicAPIsv2Api;

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $name = name_example; # String | 

eval { 
    my $result = $api_instance->getSecurityZone(name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->getSecurityZone: $@\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.PublicAPIsv2Api()
name = name_example # String | 

try: 
    api_response = api_instance.get_security_zone(name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->getSecurityZone: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PublicAPIsv2Api;

import java.io.File;
import java.util.*;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        try {
            array[RangerSecurityZoneHeaderInfo] result = apiInstance.getSecurityZoneHeaderInfoList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getSecurityZoneHeaderInfoList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        try {
            array[RangerSecurityZoneHeaderInfo] result = apiInstance.getSecurityZoneHeaderInfoList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getSecurityZoneHeaderInfoList");
            e.printStackTrace();
        }
    }
}

PublicAPIsv2Api *apiInstance = [[PublicAPIsv2Api alloc] init];

[apiInstance getSecurityZoneHeaderInfoListWithCompletionHandler: 
              ^(array[RangerSecurityZoneHeaderInfo] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSecurityZoneHeaderInfoList(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getSecurityZoneHeaderInfoListExample
    {
        public void main()
        {

            var apiInstance = new PublicAPIsv2Api();

            try
            {
                array[RangerSecurityZoneHeaderInfo] result = apiInstance.getSecurityZoneHeaderInfoList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.getSecurityZoneHeaderInfoList: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();

try {
    $result = $api_instance->getSecurityZoneHeaderInfoList();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PublicAPIsv2Api->getSecurityZoneHeaderInfoList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PublicAPIsv2Api;

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();

eval { 
    my $result = $api_instance->getSecurityZoneHeaderInfoList();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->getSecurityZoneHeaderInfoList: $@\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.PublicAPIsv2Api()

try: 
    api_response = api_instance.get_security_zone_header_info_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->getSecurityZoneHeaderInfoList: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PublicAPIsv2Api;

import java.io.File;
import java.util.*;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Long serviceId = 789; // Long | 
        Boolean isTagService = true; // Boolean | 
        try {
            array[RangerSecurityZoneHeaderInfo] result = apiInstance.getSecurityZoneHeaderInfoListByServiceId(serviceId, isTagService);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getSecurityZoneHeaderInfoListByServiceId");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Long serviceId = 789; // Long | 
        Boolean isTagService = true; // Boolean | 
        try {
            array[RangerSecurityZoneHeaderInfo] result = apiInstance.getSecurityZoneHeaderInfoListByServiceId(serviceId, isTagService);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getSecurityZoneHeaderInfoListByServiceId");
            e.printStackTrace();
        }
    }
}

Long *serviceId = 789; // 
Boolean *isTagService = true; //  (optional) (default to false)

PublicAPIsv2Api *apiInstance = [[PublicAPIsv2Api alloc] init];

[apiInstance getSecurityZoneHeaderInfoListByServiceIdWith:serviceId
    isTagService:isTagService
              completionHandler: ^(array[RangerSecurityZoneHeaderInfo] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var serviceId = 789; // {{Long}} 
var opts = { 
  'isTagService': true // {{Boolean}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSecurityZoneHeaderInfoListByServiceId(serviceId, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getSecurityZoneHeaderInfoListByServiceIdExample
    {
        public void main()
        {

            var apiInstance = new PublicAPIsv2Api();
            var serviceId = 789;  // Long | 
            var isTagService = true;  // Boolean |  (optional)  (default to false)

            try
            {
                array[RangerSecurityZoneHeaderInfo] result = apiInstance.getSecurityZoneHeaderInfoListByServiceId(serviceId, isTagService);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.getSecurityZoneHeaderInfoListByServiceId: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$serviceId = 789; // Long | 
$isTagService = true; // Boolean | 

try {
    $result = $api_instance->getSecurityZoneHeaderInfoListByServiceId($serviceId, $isTagService);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PublicAPIsv2Api->getSecurityZoneHeaderInfoListByServiceId: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PublicAPIsv2Api;

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $serviceId = 789; # Long | 
my $isTagService = true; # Boolean | 

eval { 
    my $result = $api_instance->getSecurityZoneHeaderInfoListByServiceId(serviceId => $serviceId, isTagService => $isTagService);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->getSecurityZoneHeaderInfoListByServiceId: $@\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.PublicAPIsv2Api()
serviceId = 789 # Long | 
isTagService = true # Boolean |  (optional) (default to false)

try: 
    api_response = api_instance.get_security_zone_header_info_list_by_service_id(serviceId, isTagService=isTagService)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->getSecurityZoneHeaderInfoListByServiceId: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PublicAPIsv2Api;

import java.io.File;
import java.util.*;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String serviceName = serviceName_example; // String | 
        try {
            array['String'] result = apiInstance.getSecurityZoneNamesForResource(serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getSecurityZoneNamesForResource");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String serviceName = serviceName_example; // String | 
        try {
            array['String'] result = apiInstance.getSecurityZoneNamesForResource(serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getSecurityZoneNamesForResource");
            e.printStackTrace();
        }
    }
}

String *serviceName = serviceName_example; // 

PublicAPIsv2Api *apiInstance = [[PublicAPIsv2Api alloc] init];

[apiInstance getSecurityZoneNamesForResourceWith:serviceName
              completionHandler: ^(array['String'] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var serviceName = serviceName_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSecurityZoneNamesForResource(serviceName, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getSecurityZoneNamesForResourceExample
    {
        public void main()
        {

            var apiInstance = new PublicAPIsv2Api();
            var serviceName = serviceName_example;  // String | 

            try
            {
                array['String'] result = apiInstance.getSecurityZoneNamesForResource(serviceName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.getSecurityZoneNamesForResource: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$serviceName = serviceName_example; // String | 

try {
    $result = $api_instance->getSecurityZoneNamesForResource($serviceName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PublicAPIsv2Api->getSecurityZoneNamesForResource: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PublicAPIsv2Api;

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $serviceName = serviceName_example; # String | 

eval { 
    my $result = $api_instance->getSecurityZoneNamesForResource(serviceName => $serviceName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->getSecurityZoneNamesForResource: $@\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.PublicAPIsv2Api()
serviceName = serviceName_example # String | 

try: 
    api_response = api_instance.get_security_zone_names_for_resource(serviceName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->getSecurityZoneNamesForResource: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PublicAPIsv2Api;

import java.io.File;
import java.util.*;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Long id = 789; // Long | 
        try {
            RangerSecurityZone result = apiInstance.getSecurityZone_0(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getSecurityZone_0");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Long id = 789; // Long | 
        try {
            RangerSecurityZone result = apiInstance.getSecurityZone_0(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getSecurityZone_0");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

PublicAPIsv2Api *apiInstance = [[PublicAPIsv2Api alloc] init];

[apiInstance getSecurityZone_4With:id
              completionHandler: ^(RangerSecurityZone output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var id = 789; // {{Long}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSecurityZone_0(id, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getSecurityZone_0Example
    {
        public void main()
        {

            var apiInstance = new PublicAPIsv2Api();
            var id = 789;  // Long | 

            try
            {
                RangerSecurityZone result = apiInstance.getSecurityZone_0(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.getSecurityZone_0: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$id = 789; // Long | 

try {
    $result = $api_instance->getSecurityZone_0($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PublicAPIsv2Api->getSecurityZone_0: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PublicAPIsv2Api;

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $id = 789; # Long | 

eval { 
    my $result = $api_instance->getSecurityZone_0(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->getSecurityZone_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.PublicAPIsv2Api()
id = 789 # Long | 

try: 
    api_response = api_instance.get_security_zone_0(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->getSecurityZone_0: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PublicAPIsv2Api;

import java.io.File;
import java.util.*;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Long id = 789; // Long | 
        try {
            RangerService result = apiInstance.getService2(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getService2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Long id = 789; // Long | 
        try {
            RangerService result = apiInstance.getService2(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getService2");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

PublicAPIsv2Api *apiInstance = [[PublicAPIsv2Api alloc] init];

[apiInstance getService2With:id
              completionHandler: ^(RangerService output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var id = 789; // {{Long}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getService2(id, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getService2Example
    {
        public void main()
        {

            var apiInstance = new PublicAPIsv2Api();
            var id = 789;  // Long | 

            try
            {
                RangerService result = apiInstance.getService2(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.getService2: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$id = 789; // Long | 

try {
    $result = $api_instance->getService2($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PublicAPIsv2Api->getService2: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PublicAPIsv2Api;

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $id = 789; # Long | 

eval { 
    my $result = $api_instance->getService2(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->getService2: $@\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.PublicAPIsv2Api()
id = 789 # Long | 

try: 
    api_response = api_instance.get_service2(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->getService2: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PublicAPIsv2Api;

import java.io.File;
import java.util.*;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String name = name_example; // String | 
        try {
            RangerService result = apiInstance.getServiceByName2(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getServiceByName2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String name = name_example; // String | 
        try {
            RangerService result = apiInstance.getServiceByName2(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getServiceByName2");
            e.printStackTrace();
        }
    }
}

String *name = name_example; // 

PublicAPIsv2Api *apiInstance = [[PublicAPIsv2Api alloc] init];

[apiInstance getServiceByName2With:name
              completionHandler: ^(RangerService output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var 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.getServiceByName2(name, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getServiceByName2Example
    {
        public void main()
        {

            var apiInstance = new PublicAPIsv2Api();
            var name = name_example;  // String | 

            try
            {
                RangerService result = apiInstance.getServiceByName2(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.getServiceByName2: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$name = name_example; // String | 

try {
    $result = $api_instance->getServiceByName2($name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PublicAPIsv2Api->getServiceByName2: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PublicAPIsv2Api;

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $name = name_example; # String | 

eval { 
    my $result = $api_instance->getServiceByName2(name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->getServiceByName2: $@\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.PublicAPIsv2Api()
name = name_example # String | 

try: 
    api_response = api_instance.get_service_by_name2(name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->getServiceByName2: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PublicAPIsv2Api;

import java.io.File;
import java.util.*;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Long id = 789; // Long | 
        try {
            RangerServiceDef result = apiInstance.getServiceDef2(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getServiceDef2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Long id = 789; // Long | 
        try {
            RangerServiceDef result = apiInstance.getServiceDef2(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getServiceDef2");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 

PublicAPIsv2Api *apiInstance = [[PublicAPIsv2Api alloc] init];

[apiInstance getServiceDef2With:id
              completionHandler: ^(RangerServiceDef output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var id = 789; // {{Long}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getServiceDef2(id, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getServiceDef2Example
    {
        public void main()
        {

            var apiInstance = new PublicAPIsv2Api();
            var id = 789;  // Long | 

            try
            {
                RangerServiceDef result = apiInstance.getServiceDef2(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.getServiceDef2: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$id = 789; // Long | 

try {
    $result = $api_instance->getServiceDef2($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PublicAPIsv2Api->getServiceDef2: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PublicAPIsv2Api;

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $id = 789; # Long | 

eval { 
    my $result = $api_instance->getServiceDef2(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->getServiceDef2: $@\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.PublicAPIsv2Api()
id = 789 # Long | 

try: 
    api_response = api_instance.get_service_def2(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->getServiceDef2: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PublicAPIsv2Api;

import java.io.File;
import java.util.*;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String name = name_example; // String | 
        try {
            RangerServiceDef result = apiInstance.getServiceDefByName2(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getServiceDefByName2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String name = name_example; // String | 
        try {
            RangerServiceDef result = apiInstance.getServiceDefByName2(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getServiceDefByName2");
            e.printStackTrace();
        }
    }
}

String *name = name_example; // 

PublicAPIsv2Api *apiInstance = [[PublicAPIsv2Api alloc] init];

[apiInstance getServiceDefByName2With:name
              completionHandler: ^(RangerServiceDef output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var 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.getServiceDefByName2(name, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getServiceDefByName2Example
    {
        public void main()
        {

            var apiInstance = new PublicAPIsv2Api();
            var name = name_example;  // String | 

            try
            {
                RangerServiceDef result = apiInstance.getServiceDefByName2(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.getServiceDefByName2: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$name = name_example; // String | 

try {
    $result = $api_instance->getServiceDefByName2($name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PublicAPIsv2Api->getServiceDefByName2: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PublicAPIsv2Api;

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $name = name_example; # String | 

eval { 
    my $result = $api_instance->getServiceDefByName2(name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->getServiceDefByName2: $@\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.PublicAPIsv2Api()
name = name_example # String | 

try: 
    api_response = api_instance.get_service_def_by_name2(name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->getServiceDefByName2: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PublicAPIsv2Api;

import java.io.File;
import java.util.*;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Long zoneId = 789; // Long | 
        try {
            array[RangerServiceHeaderInfo] result = apiInstance.getServiceHeaderInfoListByZoneId(zoneId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getServiceHeaderInfoListByZoneId");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Long zoneId = 789; // Long | 
        try {
            array[RangerServiceHeaderInfo] result = apiInstance.getServiceHeaderInfoListByZoneId(zoneId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getServiceHeaderInfoListByZoneId");
            e.printStackTrace();
        }
    }
}

Long *zoneId = 789; // 

PublicAPIsv2Api *apiInstance = [[PublicAPIsv2Api alloc] init];

[apiInstance getServiceHeaderInfoListByZoneIdWith:zoneId
              completionHandler: ^(array[RangerServiceHeaderInfo] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var zoneId = 789; // {{Long}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getServiceHeaderInfoListByZoneId(zoneId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getServiceHeaderInfoListByZoneIdExample
    {
        public void main()
        {

            var apiInstance = new PublicAPIsv2Api();
            var zoneId = 789;  // Long | 

            try
            {
                array[RangerServiceHeaderInfo] result = apiInstance.getServiceHeaderInfoListByZoneId(zoneId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.getServiceHeaderInfoListByZoneId: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$zoneId = 789; // Long | 

try {
    $result = $api_instance->getServiceHeaderInfoListByZoneId($zoneId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PublicAPIsv2Api->getServiceHeaderInfoListByZoneId: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PublicAPIsv2Api;

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $zoneId = 789; # Long | 

eval { 
    my $result = $api_instance->getServiceHeaderInfoListByZoneId(zoneId => $zoneId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->getServiceHeaderInfoListByZoneId: $@\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.PublicAPIsv2Api()
zoneId = 789 # Long | 

try: 
    api_response = api_instance.get_service_header_info_list_by_zone_id(zoneId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->getServiceHeaderInfoListByZoneId: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PublicAPIsv2Api;

import java.io.File;
import java.util.*;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String serviceName = serviceName_example; // String | 
        try {
            RangerServiceTags result = apiInstance.getServiceTags(serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getServiceTags");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String serviceName = serviceName_example; // String | 
        try {
            RangerServiceTags result = apiInstance.getServiceTags(serviceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getServiceTags");
            e.printStackTrace();
        }
    }
}

String *serviceName = serviceName_example; // 

PublicAPIsv2Api *apiInstance = [[PublicAPIsv2Api alloc] init];

[apiInstance getServiceTagsWith:serviceName
              completionHandler: ^(RangerServiceTags output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var serviceName = serviceName_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getServiceTags(serviceName, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getServiceTagsExample
    {
        public void main()
        {

            var apiInstance = new PublicAPIsv2Api();
            var serviceName = serviceName_example;  // String | 

            try
            {
                RangerServiceTags result = apiInstance.getServiceTags(serviceName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.getServiceTags: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$serviceName = serviceName_example; // String | 

try {
    $result = $api_instance->getServiceTags($serviceName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PublicAPIsv2Api->getServiceTags: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PublicAPIsv2Api;

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $serviceName = serviceName_example; # String | 

eval { 
    my $result = $api_instance->getServiceTags(serviceName => $serviceName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->getServiceTags: $@\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.PublicAPIsv2Api()
serviceName = serviceName_example # String | 

try: 
    api_response = api_instance.get_service_tags(serviceName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->getServiceTags: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PublicAPIsv2Api;

import java.io.File;
import java.util.*;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String user = user_example; // String | 
        try {
            array['String'] result = apiInstance.getUserRoles(user);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getUserRoles");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String user = user_example; // String | 
        try {
            array['String'] result = apiInstance.getUserRoles(user);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#getUserRoles");
            e.printStackTrace();
        }
    }
}

String *user = user_example; // 

PublicAPIsv2Api *apiInstance = [[PublicAPIsv2Api alloc] init];

[apiInstance getUserRolesWith:user
              completionHandler: ^(array['String'] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var user = user_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getUserRoles(user, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getUserRolesExample
    {
        public void main()
        {

            var apiInstance = new PublicAPIsv2Api();
            var user = user_example;  // String | 

            try
            {
                array['String'] result = apiInstance.getUserRoles(user);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.getUserRoles: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$user = user_example; // String | 

try {
    $result = $api_instance->getUserRoles($user);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PublicAPIsv2Api->getUserRoles: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PublicAPIsv2Api;

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $user = user_example; # String | 

eval { 
    my $result = $api_instance->getUserRoles(user => $user);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->getUserRoles: $@\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.PublicAPIsv2Api()
user = user_example # String | 

try: 
    api_response = api_instance.get_user_roles(user)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->getUserRoles: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PublicAPIsv2Api;

import java.io.File;
import java.util.*;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String serviceName = serviceName_example; // String | 
        GrantRevokeRoleRequest body = ; // GrantRevokeRoleRequest | 
        try {
            RESTResponse result = apiInstance.grantRole(serviceName, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#grantRole");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String serviceName = serviceName_example; // String | 
        GrantRevokeRoleRequest body = ; // GrantRevokeRoleRequest | 
        try {
            RESTResponse result = apiInstance.grantRole(serviceName, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#grantRole");
            e.printStackTrace();
        }
    }
}

String *serviceName = serviceName_example; // 
GrantRevokeRoleRequest *body = ; //  (optional)

PublicAPIsv2Api *apiInstance = [[PublicAPIsv2Api alloc] init];

[apiInstance grantRoleWith:serviceName
    body:body
              completionHandler: ^(RESTResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var serviceName = serviceName_example; // {{String}} 
var opts = { 
  'body':  // {{GrantRevokeRoleRequest}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.grantRole(serviceName, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class grantRoleExample
    {
        public void main()
        {

            var apiInstance = new PublicAPIsv2Api();
            var serviceName = serviceName_example;  // String | 
            var body = new GrantRevokeRoleRequest(); // GrantRevokeRoleRequest |  (optional) 

            try
            {
                RESTResponse result = apiInstance.grantRole(serviceName, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.grantRole: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$serviceName = serviceName_example; // String | 
$body = ; // GrantRevokeRoleRequest | 

try {
    $result = $api_instance->grantRole($serviceName, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PublicAPIsv2Api->grantRole: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PublicAPIsv2Api;

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $serviceName = serviceName_example; # String | 
my $body = WWW::SwaggerClient::Object::GrantRevokeRoleRequest->new(); # GrantRevokeRoleRequest | 

eval { 
    my $result = $api_instance->grantRole(serviceName => $serviceName, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->grantRole: $@\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.PublicAPIsv2Api()
serviceName = serviceName_example # String | 
body =  # GrantRevokeRoleRequest |  (optional)

try: 
    api_response = api_instance.grant_role(serviceName, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->grantRole: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PublicAPIsv2Api;

import java.io.File;
import java.util.*;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String serviceName = serviceName_example; // String | 
        RangerServiceTags body = ; // RangerServiceTags | 
        try {
            apiInstance.importServiceTags(serviceName, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#importServiceTags");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String serviceName = serviceName_example; // String | 
        RangerServiceTags body = ; // RangerServiceTags | 
        try {
            apiInstance.importServiceTags(serviceName, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#importServiceTags");
            e.printStackTrace();
        }
    }
}

String *serviceName = serviceName_example; // 
RangerServiceTags *body = ; //  (optional)

PublicAPIsv2Api *apiInstance = [[PublicAPIsv2Api alloc] init];

[apiInstance importServiceTagsWith:serviceName
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var serviceName = serviceName_example; // {{String}} 
var opts = { 
  'body':  // {{RangerServiceTags}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.importServiceTags(serviceName, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class importServiceTagsExample
    {
        public void main()
        {

            var apiInstance = new PublicAPIsv2Api();
            var serviceName = serviceName_example;  // String | 
            var body = new RangerServiceTags(); // RangerServiceTags |  (optional) 

            try
            {
                apiInstance.importServiceTags(serviceName, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.importServiceTags: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$serviceName = serviceName_example; // String | 
$body = ; // RangerServiceTags | 

try {
    $api_instance->importServiceTags($serviceName, $body);
} catch (Exception $e) {
    echo 'Exception when calling PublicAPIsv2Api->importServiceTags: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PublicAPIsv2Api;

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $serviceName = serviceName_example; # String | 
my $body = WWW::SwaggerClient::Object::RangerServiceTags->new(); # RangerServiceTags | 

eval { 
    $api_instance->importServiceTags(serviceName => $serviceName, body => $body);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->importServiceTags: $@\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.PublicAPIsv2Api()
serviceName = serviceName_example # String | 
body =  # RangerServiceTags |  (optional)

try: 
    api_instance.import_service_tags(serviceName, body=body)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->importServiceTags: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PublicAPIsv2Api;

import java.io.File;
import java.util.*;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String serviceName = serviceName_example; // String | 
        try {
            apiInstance.purgeEmptyPolicies2(serviceName);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#purgeEmptyPolicies2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        String serviceName = serviceName_example; // String | 
        try {
            apiInstance.purgeEmptyPolicies2(serviceName);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#purgeEmptyPolicies2");
            e.printStackTrace();
        }
    }
}

String *serviceName = serviceName_example; // 

PublicAPIsv2Api *apiInstance = [[PublicAPIsv2Api alloc] init];

[apiInstance purgeEmptyPolicies2With:serviceName
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var serviceName = serviceName_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.purgeEmptyPolicies2(serviceName, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class purgeEmptyPolicies2Example
    {
        public void main()
        {

            var apiInstance = new PublicAPIsv2Api();
            var serviceName = serviceName_example;  // String | 

            try
            {
                apiInstance.purgeEmptyPolicies2(serviceName);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.purgeEmptyPolicies2: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$serviceName = serviceName_example; // String | 

try {
    $api_instance->purgeEmptyPolicies2($serviceName);
} catch (Exception $e) {
    echo 'Exception when calling PublicAPIsv2Api->purgeEmptyPolicies2: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PublicAPIsv2Api;

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $serviceName = serviceName_example; # String | 

eval { 
    $api_instance->purgeEmptyPolicies2(serviceName => $serviceName);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->purgeEmptyPolicies2: $@\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.PublicAPIsv2Api()
serviceName = serviceName_example # String | 

try: 
    api_instance.purge_empty_policies2(serviceName)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->purgeEmptyPolicies2: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PublicAPIsv2Api;

import java.io.File;
import java.util.*;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Integer retentionDays = 56; // Integer | 
        String type = type_example; // String | 
        try {
            apiInstance.purgeRecords2(retentionDays, type);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#purgeRecords2");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Integer retentionDays = 56; // Integer | 
        String type = type_example; // String | 
        try {
            apiInstance.purgeRecords2(retentionDays, type);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#purgeRecords2");
            e.printStackTrace();
        }
    }
}

Integer *retentionDays = 56; //  (optional) (default to 180)
String *type = type_example; //  (optional)

PublicAPIsv2Api *apiInstance = [[PublicAPIsv2Api alloc] init];

[apiInstance purgeRecords2With:retentionDays
    type:type
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var opts = { 
  'retentionDays': 56, // {{Integer}} 
  'type': type_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.purgeRecords2(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class purgeRecords2Example
    {
        public void main()
        {

            var apiInstance = new PublicAPIsv2Api();
            var retentionDays = 56;  // Integer |  (optional)  (default to 180)
            var type = type_example;  // String |  (optional) 

            try
            {
                apiInstance.purgeRecords2(retentionDays, type);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.purgeRecords2: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$retentionDays = 56; // Integer | 
$type = type_example; // String | 

try {
    $api_instance->purgeRecords2($retentionDays, $type);
} catch (Exception $e) {
    echo 'Exception when calling PublicAPIsv2Api->purgeRecords2: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PublicAPIsv2Api;

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $retentionDays = 56; # Integer | 
my $type = type_example; # String | 

eval { 
    $api_instance->purgeRecords2(retentionDays => $retentionDays, type => $type);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->purgeRecords2: $@\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.PublicAPIsv2Api()
retentionDays = 56 # Integer |  (optional) (default to 180)
type = type_example # String |  (optional)

try: 
    api_instance.purge_records2(retentionDays=retentionDays, type=type)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->purgeRecords2: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PublicAPIsv2Api;

import java.io.File;
import java.util.*;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Long id = 789; // Long | 
        array[String] body = ; // array[String] | 
        try {
            RangerRole result = apiInstance.removeAdminFromUsersAndGroups(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#removeAdminFromUsersAndGroups");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PublicAPIsv2Api;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Long id = 789; // Long | 
        array[String] body = ; // array[String] | 
        try {
            RangerRole result = apiInstance.removeAdminFromUsersAndGroups(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#removeAdminFromUsersAndGroups");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // 
array[String] *body = ; //  (optional)

PublicAPIsv2Api *apiInstance = [[PublicAPIsv2Api alloc] init];

[apiInstance removeAdminFromUsersAndGroupsWith:id
    body:body
              completionHandler: ^(RangerRole output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var RangerRestApi = require('ranger_rest_api');

var api = new RangerRestApi.PublicAPIsv2Api()
var id = 789; // {{Long}} 
var opts = { 
  'body':  // {{array[String]}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.removeAdminFromUsersAndGroups(id, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class removeAdminFromUsersAndGroupsExample
    {
        public void main()
        {

            var apiInstance = new PublicAPIsv2Api();
            var id = 789;  // Long | 
            var body = new array[String](); // array[String] |  (optional) 

            try
            {
                RangerRole result = apiInstance.removeAdminFromUsersAndGroups(id, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PublicAPIsv2Api.removeAdminFromUsersAndGroups: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPublicAPIsv2Api();
$id = 789; // Long | 
$body = ; // array[String] | 

try {
    $result = $api_instance->removeAdminFromUsersAndGroups($id, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PublicAPIsv2Api->removeAdminFromUsersAndGroups: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PublicAPIsv2Api;

my $api_instance = WWW::SwaggerClient::PublicAPIsv2Api->new();
my $id = 789; # Long | 
my $body = [WWW::SwaggerClient::Object::array[String]->new()]; # array[String] | 

eval { 
    my $result = $api_instance->removeAdminFromUsersAndGroups(id => $id, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PublicAPIsv2Api->removeAdminFromUsersAndGroups: $@\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.PublicAPIsv2Api()
id = 789 # Long | 
body =  # array[String] |  (optional)

try: 
    api_response = api_instance.remove_admin_from_users_and_groups(id, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PublicAPIsv2Api->removeAdminFromUsersAndGroups: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PublicAPIsv2Api;

import java.io.File;
import java.util.*;

public class PublicAPIsv2ApiExample {

    public static void main(String[] args) {
        
        PublicAPIsv2Api apiInstance = new PublicAPIsv2Api();
        Long id = 789; // Long | 
        array[String] body = ; // array[String] | 
        try {
            RangerRole result = apiInstance.removeUsersAndGroups(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicAPIsv2Api#removeUsersAndGroups");
            e.printStackTrace();
        }
    }
}