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

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

public class E2eServiceInstancesApiExample {

    public static void main(String[] args) {
        
        E2eServiceInstancesApi apiInstance = new E2eServiceInstancesApi();
        String version = version_example; // String | 
        String serviceId = serviceId_example; // String | 
        String operationType = operationType_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.activateE2EServiceInstances(version, serviceId, operationType, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling E2eServiceInstancesApi#activateE2EServiceInstances");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.E2eServiceInstancesApi;

public class E2eServiceInstancesApiExample {

    public static void main(String[] args) {
        E2eServiceInstancesApi apiInstance = new E2eServiceInstancesApi();
        String version = version_example; // String | 
        String serviceId = serviceId_example; // String | 
        String operationType = operationType_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.activateE2EServiceInstances(version, serviceId, operationType, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling E2eServiceInstancesApi#activateE2EServiceInstances");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceId = serviceId_example; // 
String *operationType = operationType_example; // 
String *body = body_example; //  (optional)

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

// Activate/Deactivate 5G slice Service on a specified version and serviceId
[apiInstance activateE2EServiceInstancesWith:version
    serviceId:serviceId
    operationType:operationType
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.E2eServiceInstancesApi()

var version = version_example; // {String} 

var serviceId = serviceId_example; // {String} 

var operationType = operationType_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class activateE2EServiceInstancesExample
    {
        public void main()
        {
            
            var apiInstance = new E2eServiceInstancesApi();
            var version = version_example;  // String | 
            var serviceId = serviceId_example;  // String | 
            var operationType = operationType_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Activate/Deactivate 5G slice Service on a specified version and serviceId
                apiInstance.activateE2EServiceInstances(version, serviceId, operationType, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling E2eServiceInstancesApi.activateE2EServiceInstances: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\E2eServiceInstancesApi();
$version = version_example; // String | 
$serviceId = serviceId_example; // String | 
$operationType = operationType_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->activateE2EServiceInstances($version, $serviceId, $operationType, $body);
} catch (Exception $e) {
    echo 'Exception when calling E2eServiceInstancesApi->activateE2EServiceInstances: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::E2eServiceInstancesApi->new();
my $version = version_example; # String | 
my $serviceId = serviceId_example; # String | 
my $operationType = operationType_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->activateE2EServiceInstances(version => $version, serviceId => $serviceId, operationType => $operationType, body => $body);
};
if ($@) {
    warn "Exception when calling E2eServiceInstancesApi->activateE2EServiceInstances: $@\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.E2eServiceInstancesApi()
version = version_example # String | 
serviceId = serviceId_example # String | 
operationType = operationType_example # String | 
body = body_example # String |  (optional)

try: 
    # Activate/Deactivate 5G slice Service on a specified version and serviceId
    api_instance.activate_e2_e_service_instances(version, serviceId, operationType, body=body)
except ApiException as e:
    print("Exception when calling E2eServiceInstancesApi->activateE2EServiceInstances: %s\n" % e)

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

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

public class E2eServiceInstancesApiExample {

    public static void main(String[] args) {
        
        E2eServiceInstancesApi apiInstance = new E2eServiceInstancesApi();
        String serviceId = serviceId_example; // String | 
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.compareModelwithTargetVersion(serviceId, version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling E2eServiceInstancesApi#compareModelwithTargetVersion");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.E2eServiceInstancesApi;

public class E2eServiceInstancesApiExample {

    public static void main(String[] args) {
        E2eServiceInstancesApi apiInstance = new E2eServiceInstancesApi();
        String serviceId = serviceId_example; // String | 
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.compareModelwithTargetVersion(serviceId, version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling E2eServiceInstancesApi#compareModelwithTargetVersion");
            e.printStackTrace();
        }
    }
}

String *serviceId = serviceId_example; // 
String *version = version_example; // 
String *body = body_example; //  (optional)

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

// Find added and deleted resources of target model for the e2eserviceInstance on a given serviceId 
[apiInstance compareModelwithTargetVersionWith:serviceId
    version:version
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.E2eServiceInstancesApi()

var serviceId = serviceId_example; // {String} 

var version = version_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class compareModelwithTargetVersionExample
    {
        public void main()
        {
            
            var apiInstance = new E2eServiceInstancesApi();
            var serviceId = serviceId_example;  // String | 
            var version = version_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Find added and deleted resources of target model for the e2eserviceInstance on a given serviceId 
                apiInstance.compareModelwithTargetVersion(serviceId, version, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling E2eServiceInstancesApi.compareModelwithTargetVersion: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\E2eServiceInstancesApi();
$serviceId = serviceId_example; // String | 
$version = version_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->compareModelwithTargetVersion($serviceId, $version, $body);
} catch (Exception $e) {
    echo 'Exception when calling E2eServiceInstancesApi->compareModelwithTargetVersion: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::E2eServiceInstancesApi->new();
my $serviceId = serviceId_example; # String | 
my $version = version_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->compareModelwithTargetVersion(serviceId => $serviceId, version => $version, body => $body);
};
if ($@) {
    warn "Exception when calling E2eServiceInstancesApi->compareModelwithTargetVersion: $@\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.E2eServiceInstancesApi()
serviceId = serviceId_example # String | 
version = version_example # String | 
body = body_example # String |  (optional)

try: 
    # Find added and deleted resources of target model for the e2eserviceInstance on a given serviceId 
    api_instance.compare_modelwith_target_version(serviceId, version, body=body)
except ApiException as e:
    print("Exception when calling E2eServiceInstancesApi->compareModelwithTargetVersion: %s\n" % e)

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

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

public class E2eServiceInstancesApiExample {

    public static void main(String[] args) {
        
        E2eServiceInstancesApi apiInstance = new E2eServiceInstancesApi();
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createE2EServiceInstance(version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling E2eServiceInstancesApi#createE2EServiceInstance");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.E2eServiceInstancesApi;

public class E2eServiceInstancesApiExample {

    public static void main(String[] args) {
        E2eServiceInstancesApi apiInstance = new E2eServiceInstancesApi();
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createE2EServiceInstance(version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling E2eServiceInstancesApi#createE2EServiceInstance");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *body = body_example; //  (optional)

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

// Create an E2E Service Instance on a version provided
[apiInstance createE2EServiceInstanceWith:version
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.E2eServiceInstancesApi()

var version = version_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class createE2EServiceInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new E2eServiceInstancesApi();
            var version = version_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Create an E2E Service Instance on a version provided
                apiInstance.createE2EServiceInstance(version, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling E2eServiceInstancesApi.createE2EServiceInstance: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\E2eServiceInstancesApi();
$version = version_example; // String | 
$body = body_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::E2eServiceInstancesApi->new();
my $version = version_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->createE2EServiceInstance(version => $version, body => $body);
};
if ($@) {
    warn "Exception when calling E2eServiceInstancesApi->createE2EServiceInstance: $@\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.E2eServiceInstancesApi()
version = version_example # String | 
body = body_example # String |  (optional)

try: 
    # Create an E2E Service Instance on a version provided
    api_instance.create_e2_e_service_instance(version, body=body)
except ApiException as e:
    print("Exception when calling E2eServiceInstancesApi->createE2EServiceInstance: %s\n" % e)

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

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

public class E2eServiceInstancesApiExample {

    public static void main(String[] args) {
        
        E2eServiceInstancesApi apiInstance = new E2eServiceInstancesApi();
        String version = version_example; // String | 
        String serviceId = serviceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deleteE2EServiceInstance(version, serviceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling E2eServiceInstancesApi#deleteE2EServiceInstance");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.E2eServiceInstancesApi;

public class E2eServiceInstancesApiExample {

    public static void main(String[] args) {
        E2eServiceInstancesApi apiInstance = new E2eServiceInstancesApi();
        String version = version_example; // String | 
        String serviceId = serviceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deleteE2EServiceInstance(version, serviceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling E2eServiceInstancesApi#deleteE2EServiceInstance");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceId = serviceId_example; // 
String *body = body_example; //  (optional)

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

// Delete E2E Service Instance on a specified version and serviceId
[apiInstance deleteE2EServiceInstanceWith:version
    serviceId:serviceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.E2eServiceInstancesApi()

var version = version_example; // {String} 

var serviceId = serviceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class deleteE2EServiceInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new E2eServiceInstancesApi();
            var version = version_example;  // String | 
            var serviceId = serviceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Delete E2E Service Instance on a specified version and serviceId
                apiInstance.deleteE2EServiceInstance(version, serviceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling E2eServiceInstancesApi.deleteE2EServiceInstance: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\E2eServiceInstancesApi();
$version = version_example; // String | 
$serviceId = serviceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->deleteE2EServiceInstance($version, $serviceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling E2eServiceInstancesApi->deleteE2EServiceInstance: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::E2eServiceInstancesApi->new();
my $version = version_example; # String | 
my $serviceId = serviceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->deleteE2EServiceInstance(version => $version, serviceId => $serviceId, body => $body);
};
if ($@) {
    warn "Exception when calling E2eServiceInstancesApi->deleteE2EServiceInstance: $@\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.E2eServiceInstancesApi()
version = version_example # String | 
serviceId = serviceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Delete E2E Service Instance on a specified version and serviceId
    api_instance.delete_e2_e_service_instance(version, serviceId, body=body)
except ApiException as e:
    print("Exception when calling E2eServiceInstancesApi->deleteE2EServiceInstance: %s\n" % e)

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

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

public class E2eServiceInstancesApiExample {

    public static void main(String[] args) {
        
        E2eServiceInstancesApi apiInstance = new E2eServiceInstancesApi();
        String serviceId = serviceId_example; // String | 
        String version = version_example; // String | 
        String operationId = operationId_example; // String | 
        try {
            apiInstance.getE2EServiceInstances(serviceId, version, operationId);
        } catch (ApiException e) {
            System.err.println("Exception when calling E2eServiceInstancesApi#getE2EServiceInstances");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.E2eServiceInstancesApi;

public class E2eServiceInstancesApiExample {

    public static void main(String[] args) {
        E2eServiceInstancesApi apiInstance = new E2eServiceInstancesApi();
        String serviceId = serviceId_example; // String | 
        String version = version_example; // String | 
        String operationId = operationId_example; // String | 
        try {
            apiInstance.getE2EServiceInstances(serviceId, version, operationId);
        } catch (ApiException e) {
            System.err.println("Exception when calling E2eServiceInstancesApi#getE2EServiceInstances");
            e.printStackTrace();
        }
    }
}

String *serviceId = serviceId_example; // 
String *version = version_example; // 
String *operationId = operationId_example; // 

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

// Find e2eServiceInstances Requests for a given serviceId and operationId
[apiInstance getE2EServiceInstancesWith:serviceId
    version:version
    operationId:operationId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.E2eServiceInstancesApi()

var serviceId = serviceId_example; // {String} 

var version = version_example; // {String} 

var operationId = operationId_example; // {String} 


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

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

namespace Example
{
    public class getE2EServiceInstancesExample
    {
        public void main()
        {
            
            var apiInstance = new E2eServiceInstancesApi();
            var serviceId = serviceId_example;  // String | 
            var version = version_example;  // String | 
            var operationId = operationId_example;  // String | 

            try
            {
                // Find e2eServiceInstances Requests for a given serviceId and operationId
                apiInstance.getE2EServiceInstances(serviceId, version, operationId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling E2eServiceInstancesApi.getE2EServiceInstances: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\E2eServiceInstancesApi();
$serviceId = serviceId_example; // String | 
$version = version_example; // String | 
$operationId = operationId_example; // String | 

try {
    $api_instance->getE2EServiceInstances($serviceId, $version, $operationId);
} catch (Exception $e) {
    echo 'Exception when calling E2eServiceInstancesApi->getE2EServiceInstances: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::E2eServiceInstancesApi->new();
my $serviceId = serviceId_example; # String | 
my $version = version_example; # String | 
my $operationId = operationId_example; # String | 

eval { 
    $api_instance->getE2EServiceInstances(serviceId => $serviceId, version => $version, operationId => $operationId);
};
if ($@) {
    warn "Exception when calling E2eServiceInstancesApi->getE2EServiceInstances: $@\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.E2eServiceInstancesApi()
serviceId = serviceId_example # String | 
version = version_example # String | 
operationId = operationId_example # String | 

try: 
    # Find e2eServiceInstances Requests for a given serviceId and operationId
    api_instance.get_e2_e_service_instances(serviceId, version, operationId)
except ApiException as e:
    print("Exception when calling E2eServiceInstancesApi->getE2EServiceInstances: %s\n" % e)

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

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

public class E2eServiceInstancesApiExample {

    public static void main(String[] args) {
        
        E2eServiceInstancesApi apiInstance = new E2eServiceInstancesApi();
        String version = version_example; // String | 
        String serviceId = serviceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.scaleE2EServiceInstance(version, serviceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling E2eServiceInstancesApi#scaleE2EServiceInstance");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.E2eServiceInstancesApi;

public class E2eServiceInstancesApiExample {

    public static void main(String[] args) {
        E2eServiceInstancesApi apiInstance = new E2eServiceInstancesApi();
        String version = version_example; // String | 
        String serviceId = serviceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.scaleE2EServiceInstance(version, serviceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling E2eServiceInstancesApi#scaleE2EServiceInstance");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceId = serviceId_example; // 
String *body = body_example; //  (optional)

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

// Scale E2E Service Instance on a specified version
[apiInstance scaleE2EServiceInstanceWith:version
    serviceId:serviceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.E2eServiceInstancesApi()

var version = version_example; // {String} 

var serviceId = serviceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class scaleE2EServiceInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new E2eServiceInstancesApi();
            var version = version_example;  // String | 
            var serviceId = serviceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Scale E2E Service Instance on a specified version
                apiInstance.scaleE2EServiceInstance(version, serviceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling E2eServiceInstancesApi.scaleE2EServiceInstance: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\E2eServiceInstancesApi();
$version = version_example; // String | 
$serviceId = serviceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->scaleE2EServiceInstance($version, $serviceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling E2eServiceInstancesApi->scaleE2EServiceInstance: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::E2eServiceInstancesApi->new();
my $version = version_example; # String | 
my $serviceId = serviceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->scaleE2EServiceInstance(version => $version, serviceId => $serviceId, body => $body);
};
if ($@) {
    warn "Exception when calling E2eServiceInstancesApi->scaleE2EServiceInstance: $@\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.E2eServiceInstancesApi()
version = version_example # String | 
serviceId = serviceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Scale E2E Service Instance on a specified version
    api_instance.scale_e2_e_service_instance(version, serviceId, body=body)
except ApiException as e:
    print("Exception when calling E2eServiceInstancesApi->scaleE2EServiceInstance: %s\n" % e)

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

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

public class E2eServiceInstancesApiExample {

    public static void main(String[] args) {
        
        E2eServiceInstancesApi apiInstance = new E2eServiceInstancesApi();
        String version = version_example; // String | 
        String serviceId = serviceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.updateE2EServiceInstance(version, serviceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling E2eServiceInstancesApi#updateE2EServiceInstance");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.E2eServiceInstancesApi;

public class E2eServiceInstancesApiExample {

    public static void main(String[] args) {
        E2eServiceInstancesApi apiInstance = new E2eServiceInstancesApi();
        String version = version_example; // String | 
        String serviceId = serviceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.updateE2EServiceInstance(version, serviceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling E2eServiceInstancesApi#updateE2EServiceInstance");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceId = serviceId_example; // 
String *body = body_example; //  (optional)

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

// Update an E2E Service Instance on a version provided and serviceId
[apiInstance updateE2EServiceInstanceWith:version
    serviceId:serviceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.E2eServiceInstancesApi()

var version = version_example; // {String} 

var serviceId = serviceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class updateE2EServiceInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new E2eServiceInstancesApi();
            var version = version_example;  // String | 
            var serviceId = serviceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Update an E2E Service Instance on a version provided and serviceId
                apiInstance.updateE2EServiceInstance(version, serviceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling E2eServiceInstancesApi.updateE2EServiceInstance: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\E2eServiceInstancesApi();
$version = version_example; // String | 
$serviceId = serviceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->updateE2EServiceInstance($version, $serviceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling E2eServiceInstancesApi->updateE2EServiceInstance: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::E2eServiceInstancesApi->new();
my $version = version_example; # String | 
my $serviceId = serviceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->updateE2EServiceInstance(version => $version, serviceId => $serviceId, body => $body);
};
if ($@) {
    warn "Exception when calling E2eServiceInstancesApi->updateE2EServiceInstance: $@\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.E2eServiceInstancesApi()
version = version_example # String | 
serviceId = serviceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Update an E2E Service Instance on a version provided and serviceId
    api_instance.update_e2_e_service_instance(version, serviceId, body=body)
except ApiException as e:
    print("Exception when calling E2eServiceInstancesApi->updateE2EServiceInstance: %s\n" % e)

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

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

public class GlobalhealthcheckApiExample {

    public static void main(String[] args) {
        
        GlobalhealthcheckApi apiInstance = new GlobalhealthcheckApi();
        Boolean enableBpmn = true; // Boolean | 
        try {
            apiInstance.globalHealthcheck(enableBpmn);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlobalhealthcheckApi#globalHealthcheck");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GlobalhealthcheckApi;

public class GlobalhealthcheckApiExample {

    public static void main(String[] args) {
        GlobalhealthcheckApi apiInstance = new GlobalhealthcheckApi();
        Boolean enableBpmn = true; // Boolean | 
        try {
            apiInstance.globalHealthcheck(enableBpmn);
        } catch (ApiException e) {
            System.err.println("Exception when calling GlobalhealthcheckApi#globalHealthcheck");
            e.printStackTrace();
        }
    }
}

Boolean *enableBpmn = true; //  (optional) (default to true)

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

// Performing global health check
[apiInstance globalHealthcheckWith:enableBpmn
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.GlobalhealthcheckApi()

var opts = { 
  'enableBpmn': true // {Boolean} 
};

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

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

namespace Example
{
    public class globalHealthcheckExample
    {
        public void main()
        {
            
            var apiInstance = new GlobalhealthcheckApi();
            var enableBpmn = true;  // Boolean |  (optional)  (default to true)

            try
            {
                // Performing global health check
                apiInstance.globalHealthcheck(enableBpmn);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GlobalhealthcheckApi.globalHealthcheck: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\GlobalhealthcheckApi();
$enableBpmn = true; // Boolean | 

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

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

my $api_instance = WWW::SwaggerClient::GlobalhealthcheckApi->new();
my $enableBpmn = true; # Boolean | 

eval { 
    $api_instance->globalHealthcheck(enableBpmn => $enableBpmn);
};
if ($@) {
    warn "Exception when calling GlobalhealthcheckApi->globalHealthcheck: $@\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.GlobalhealthcheckApi()
enableBpmn = true # Boolean |  (optional) (default to true)

try: 
    # Performing global health check
    api_instance.global_healthcheck(enableBpmn=enableBpmn)
except ApiException as e:
    print("Exception when calling GlobalhealthcheckApi->globalHealthcheck: %s\n" % e)

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

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

public class NodehealthcheckApiExample {

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

import io.swagger.client.api.NodehealthcheckApi;

public class NodehealthcheckApiExample {

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

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

// Performing node health check
[apiInstance nodeHealthcheckWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.NodehealthcheckApi()

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

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

namespace Example
{
    public class nodeHealthcheckExample
    {
        public void main()
        {
            
            var apiInstance = new NodehealthcheckApi();

            try
            {
                // Performing node health check
                apiInstance.nodeHealthcheck();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NodehealthcheckApi.nodeHealthcheck: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\NodehealthcheckApi();

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

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

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

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

try: 
    # Performing node health check
    api_instance.node_healthcheck()
except ApiException as e:
    print("Exception when calling NodehealthcheckApi->nodeHealthcheck: %s\n" % e)

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

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

public class Onap3gppServiceInstancesApiExample {

    public static void main(String[] args) {
        
        Onap3gppServiceInstancesApi apiInstance = new Onap3gppServiceInstancesApi();
        3gppServiceActivation body = ; // 3gppServiceActivation | 
        String version = version_example; // String | 
        try {
            3gppServiceResponse result = apiInstance.activate3gppService(body, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Onap3gppServiceInstancesApi#activate3gppService");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Onap3gppServiceInstancesApi;

public class Onap3gppServiceInstancesApiExample {

    public static void main(String[] args) {
        Onap3gppServiceInstancesApi apiInstance = new Onap3gppServiceInstancesApi();
        3gppServiceActivation body = ; // 3gppServiceActivation | 
        String version = version_example; // String | 
        try {
            3gppServiceResponse result = apiInstance.activate3gppService(body, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Onap3gppServiceInstancesApi#activate3gppService");
            e.printStackTrace();
        }
    }
}

3gppServiceActivation *body = ; // 
String *version = version_example; // 

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

// Activate a 3GPP Service Instance on a version provided
[apiInstance activate3gppServiceWith:body
    version:version
              completionHandler: ^(3gppServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.Onap3gppServiceInstancesApi()

var body = ; // {3gppServiceActivation} 

var version = version_example; // {String} 


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

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

namespace Example
{
    public class activate3gppServiceExample
    {
        public void main()
        {
            
            var apiInstance = new Onap3gppServiceInstancesApi();
            var body = new 3gppServiceActivation(); // 3gppServiceActivation | 
            var version = version_example;  // String | 

            try
            {
                // Activate a 3GPP Service Instance on a version provided
                3gppServiceResponse result = apiInstance.activate3gppService(body, version);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Onap3gppServiceInstancesApi.activate3gppService: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\Onap3gppServiceInstancesApi();
$body = ; // 3gppServiceActivation | 
$version = version_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::Onap3gppServiceInstancesApi->new();
my $body = WWW::SwaggerClient::Object::3gppServiceActivation->new(); # 3gppServiceActivation | 
my $version = version_example; # String | 

eval { 
    my $result = $api_instance->activate3gppService(body => $body, version => $version);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Onap3gppServiceInstancesApi->activate3gppService: $@\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.Onap3gppServiceInstancesApi()
body =  # 3gppServiceActivation | 
version = version_example # String | 

try: 
    # Activate a 3GPP Service Instance on a version provided
    api_response = api_instance.activate3gpp_service(body, version)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Onap3gppServiceInstancesApi->activate3gppService: %s\n" % e)

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

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

public class Onap3gppServiceInstancesApiExample {

    public static void main(String[] args) {
        
        Onap3gppServiceInstancesApi apiInstance = new Onap3gppServiceInstancesApi();
        Allocate3gppService body = ; // Allocate3gppService | 
        String version = version_example; // String | 
        try {
            3gppServiceResponse result = apiInstance.allocate3gppService(body, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Onap3gppServiceInstancesApi#allocate3gppService");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Onap3gppServiceInstancesApi;

public class Onap3gppServiceInstancesApiExample {

    public static void main(String[] args) {
        Onap3gppServiceInstancesApi apiInstance = new Onap3gppServiceInstancesApi();
        Allocate3gppService body = ; // Allocate3gppService | 
        String version = version_example; // String | 
        try {
            3gppServiceResponse result = apiInstance.allocate3gppService(body, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Onap3gppServiceInstancesApi#allocate3gppService");
            e.printStackTrace();
        }
    }
}

Allocate3gppService *body = ; // 
String *version = version_example; // 

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

// Create a 3GPP Service Instance on a version provided
[apiInstance allocate3gppServiceWith:body
    version:version
              completionHandler: ^(3gppServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.Onap3gppServiceInstancesApi()

var body = ; // {Allocate3gppService} 

var version = version_example; // {String} 


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

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

namespace Example
{
    public class allocate3gppServiceExample
    {
        public void main()
        {
            
            var apiInstance = new Onap3gppServiceInstancesApi();
            var body = new Allocate3gppService(); // Allocate3gppService | 
            var version = version_example;  // String | 

            try
            {
                // Create a 3GPP Service Instance on a version provided
                3gppServiceResponse result = apiInstance.allocate3gppService(body, version);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Onap3gppServiceInstancesApi.allocate3gppService: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\Onap3gppServiceInstancesApi();
$body = ; // Allocate3gppService | 
$version = version_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::Onap3gppServiceInstancesApi->new();
my $body = WWW::SwaggerClient::Object::Allocate3gppService->new(); # Allocate3gppService | 
my $version = version_example; # String | 

eval { 
    my $result = $api_instance->allocate3gppService(body => $body, version => $version);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Onap3gppServiceInstancesApi->allocate3gppService: $@\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.Onap3gppServiceInstancesApi()
body =  # Allocate3gppService | 
version = version_example # String | 

try: 
    # Create a 3GPP Service Instance on a version provided
    api_response = api_instance.allocate3gpp_service(body, version)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Onap3gppServiceInstancesApi->allocate3gppService: %s\n" % e)

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

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

public class Onap3gppServiceInstancesApiExample {

    public static void main(String[] args) {
        
        Onap3gppServiceInstancesApi apiInstance = new Onap3gppServiceInstancesApi();
        3gppServiceActivation body = ; // 3gppServiceActivation | 
        String version = version_example; // String | 
        try {
            3gppServiceResponse result = apiInstance.deactivate3gppService(body, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Onap3gppServiceInstancesApi#deactivate3gppService");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Onap3gppServiceInstancesApi;

public class Onap3gppServiceInstancesApiExample {

    public static void main(String[] args) {
        Onap3gppServiceInstancesApi apiInstance = new Onap3gppServiceInstancesApi();
        3gppServiceActivation body = ; // 3gppServiceActivation | 
        String version = version_example; // String | 
        try {
            3gppServiceResponse result = apiInstance.deactivate3gppService(body, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Onap3gppServiceInstancesApi#deactivate3gppService");
            e.printStackTrace();
        }
    }
}

3gppServiceActivation *body = ; // 
String *version = version_example; // 

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

// Deactivate a 3GPP Service Instance on a version provided
[apiInstance deactivate3gppServiceWith:body
    version:version
              completionHandler: ^(3gppServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.Onap3gppServiceInstancesApi()

var body = ; // {3gppServiceActivation} 

var version = version_example; // {String} 


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

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

namespace Example
{
    public class deactivate3gppServiceExample
    {
        public void main()
        {
            
            var apiInstance = new Onap3gppServiceInstancesApi();
            var body = new 3gppServiceActivation(); // 3gppServiceActivation | 
            var version = version_example;  // String | 

            try
            {
                // Deactivate a 3GPP Service Instance on a version provided
                3gppServiceResponse result = apiInstance.deactivate3gppService(body, version);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Onap3gppServiceInstancesApi.deactivate3gppService: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\Onap3gppServiceInstancesApi();
$body = ; // 3gppServiceActivation | 
$version = version_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::Onap3gppServiceInstancesApi->new();
my $body = WWW::SwaggerClient::Object::3gppServiceActivation->new(); # 3gppServiceActivation | 
my $version = version_example; # String | 

eval { 
    my $result = $api_instance->deactivate3gppService(body => $body, version => $version);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Onap3gppServiceInstancesApi->deactivate3gppService: $@\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.Onap3gppServiceInstancesApi()
body =  # 3gppServiceActivation | 
version = version_example # String | 

try: 
    # Deactivate a 3GPP Service Instance on a version provided
    api_response = api_instance.deactivate3gpp_service(body, version)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Onap3gppServiceInstancesApi->deactivate3gppService: %s\n" % e)

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

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

public class Onap3gppServiceInstancesApiExample {

    public static void main(String[] args) {
        
        Onap3gppServiceInstancesApi apiInstance = new Onap3gppServiceInstancesApi();
        DeAllocate3gppService body = ; // DeAllocate3gppService | 
        String version = version_example; // String | 
        try {
            3gppServiceResponse result = apiInstance.deallocate3gppService(body, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Onap3gppServiceInstancesApi#deallocate3gppService");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Onap3gppServiceInstancesApi;

public class Onap3gppServiceInstancesApiExample {

    public static void main(String[] args) {
        Onap3gppServiceInstancesApi apiInstance = new Onap3gppServiceInstancesApi();
        DeAllocate3gppService body = ; // DeAllocate3gppService | 
        String version = version_example; // String | 
        try {
            3gppServiceResponse result = apiInstance.deallocate3gppService(body, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Onap3gppServiceInstancesApi#deallocate3gppService");
            e.printStackTrace();
        }
    }
}

DeAllocate3gppService *body = ; // 
String *version = version_example; // 

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

// Terminate/Deallocate a 3GPP Service Instance on a version provided
[apiInstance deallocate3gppServiceWith:body
    version:version
              completionHandler: ^(3gppServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.Onap3gppServiceInstancesApi()

var body = ; // {DeAllocate3gppService} 

var version = version_example; // {String} 


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

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

namespace Example
{
    public class deallocate3gppServiceExample
    {
        public void main()
        {
            
            var apiInstance = new Onap3gppServiceInstancesApi();
            var body = new DeAllocate3gppService(); // DeAllocate3gppService | 
            var version = version_example;  // String | 

            try
            {
                // Terminate/Deallocate a 3GPP Service Instance on a version provided
                3gppServiceResponse result = apiInstance.deallocate3gppService(body, version);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Onap3gppServiceInstancesApi.deallocate3gppService: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\Onap3gppServiceInstancesApi();
$body = ; // DeAllocate3gppService | 
$version = version_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::Onap3gppServiceInstancesApi->new();
my $body = WWW::SwaggerClient::Object::DeAllocate3gppService->new(); # DeAllocate3gppService | 
my $version = version_example; # String | 

eval { 
    my $result = $api_instance->deallocate3gppService(body => $body, version => $version);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Onap3gppServiceInstancesApi->deallocate3gppService: $@\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.Onap3gppServiceInstancesApi()
body =  # DeAllocate3gppService | 
version = version_example # String | 

try: 
    # Terminate/Deallocate a 3GPP Service Instance on a version provided
    api_response = api_instance.deallocate3gpp_service(body, version)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Onap3gppServiceInstancesApi->deallocate3gppService: %s\n" % e)

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

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

public class Onap3gppServiceInstancesApiExample {

    public static void main(String[] args) {
        
        Onap3gppServiceInstancesApi apiInstance = new Onap3gppServiceInstancesApi();
        Modify3gppService body = ; // Modify3gppService | 
        String version = version_example; // String | 
        try {
            3gppServiceResponse result = apiInstance.modify3gppService(body, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Onap3gppServiceInstancesApi#modify3gppService");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Onap3gppServiceInstancesApi;

public class Onap3gppServiceInstancesApiExample {

    public static void main(String[] args) {
        Onap3gppServiceInstancesApi apiInstance = new Onap3gppServiceInstancesApi();
        Modify3gppService body = ; // Modify3gppService | 
        String version = version_example; // String | 
        try {
            3gppServiceResponse result = apiInstance.modify3gppService(body, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Onap3gppServiceInstancesApi#modify3gppService");
            e.printStackTrace();
        }
    }
}

Modify3gppService *body = ; // 
String *version = version_example; // 

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

// Modify a 3GPP Service Instance on a version provided
[apiInstance modify3gppServiceWith:body
    version:version
              completionHandler: ^(3gppServiceResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.Onap3gppServiceInstancesApi()

var body = ; // {Modify3gppService} 

var version = version_example; // {String} 


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

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

namespace Example
{
    public class modify3gppServiceExample
    {
        public void main()
        {
            
            var apiInstance = new Onap3gppServiceInstancesApi();
            var body = new Modify3gppService(); // Modify3gppService | 
            var version = version_example;  // String | 

            try
            {
                // Modify a 3GPP Service Instance on a version provided
                3gppServiceResponse result = apiInstance.modify3gppService(body, version);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Onap3gppServiceInstancesApi.modify3gppService: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\Onap3gppServiceInstancesApi();
$body = ; // Modify3gppService | 
$version = version_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::Onap3gppServiceInstancesApi->new();
my $body = WWW::SwaggerClient::Object::Modify3gppService->new(); # Modify3gppService | 
my $version = version_example; # String | 

eval { 
    my $result = $api_instance->modify3gppService(body => $body, version => $version);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Onap3gppServiceInstancesApi->modify3gppService: $@\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.Onap3gppServiceInstancesApi()
body =  # Modify3gppService | 
version = version_example # String | 

try: 
    # Modify a 3GPP Service Instance on a version provided
    api_response = api_instance.modify3gpp_service(body, version)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Onap3gppServiceInstancesApi->modify3gppService: %s\n" % e)

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

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

public class Onap3gppServiceInstancesApiExample {

    public static void main(String[] args) {
        
        Onap3gppServiceInstancesApi apiInstance = new Onap3gppServiceInstancesApi();
        QuerySubnetCapability body = ; // QuerySubnetCapability | 
        String version = version_example; // String | 
        try {
            Object result = apiInstance.querySubnetCapability(body, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Onap3gppServiceInstancesApi#querySubnetCapability");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Onap3gppServiceInstancesApi;

public class Onap3gppServiceInstancesApiExample {

    public static void main(String[] args) {
        Onap3gppServiceInstancesApi apiInstance = new Onap3gppServiceInstancesApi();
        QuerySubnetCapability body = ; // QuerySubnetCapability | 
        String version = version_example; // String | 
        try {
            Object result = apiInstance.querySubnetCapability(body, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Onap3gppServiceInstancesApi#querySubnetCapability");
            e.printStackTrace();
        }
    }
}

QuerySubnetCapability *body = ; // 
String *version = version_example; // 

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

// Provides subnet capability based on subnet types
[apiInstance querySubnetCapabilityWith:body
    version:version
              completionHandler: ^(Object output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.Onap3gppServiceInstancesApi()

var body = ; // {QuerySubnetCapability} 

var version = version_example; // {String} 


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

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

namespace Example
{
    public class querySubnetCapabilityExample
    {
        public void main()
        {
            
            var apiInstance = new Onap3gppServiceInstancesApi();
            var body = new QuerySubnetCapability(); // QuerySubnetCapability | 
            var version = version_example;  // String | 

            try
            {
                // Provides subnet capability based on subnet types
                Object result = apiInstance.querySubnetCapability(body, version);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Onap3gppServiceInstancesApi.querySubnetCapability: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\Onap3gppServiceInstancesApi();
$body = ; // QuerySubnetCapability | 
$version = version_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::Onap3gppServiceInstancesApi->new();
my $body = WWW::SwaggerClient::Object::QuerySubnetCapability->new(); # QuerySubnetCapability | 
my $version = version_example; # String | 

eval { 
    my $result = $api_instance->querySubnetCapability(body => $body, version => $version);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Onap3gppServiceInstancesApi->querySubnetCapability: $@\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.Onap3gppServiceInstancesApi()
body =  # QuerySubnetCapability | 
version = version_example # String | 

try: 
    # Provides subnet capability based on subnet types
    api_response = api_instance.query_subnet_capability(body, version)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Onap3gppServiceInstancesApi->querySubnetCapability: %s\n" % e)

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

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

public class OnapsoinfracloudResourcesApiExample {

    public static void main(String[] args) {
        
        OnapsoinfracloudResourcesApi apiInstance = new OnapsoinfracloudResourcesApi();
        String version = version_example; // String | 
        String operationalEnvironmentId = operationalEnvironmentId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.activateOperationEnvironment(version, operationalEnvironmentId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfracloudResourcesApi#activateOperationEnvironment");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfracloudResourcesApi;

public class OnapsoinfracloudResourcesApiExample {

    public static void main(String[] args) {
        OnapsoinfracloudResourcesApi apiInstance = new OnapsoinfracloudResourcesApi();
        String version = version_example; // String | 
        String operationalEnvironmentId = operationalEnvironmentId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.activateOperationEnvironment(version, operationalEnvironmentId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfracloudResourcesApi#activateOperationEnvironment");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *operationalEnvironmentId = operationalEnvironmentId_example; // 
String *body = body_example; //  (optional)

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

// Activate an Operational Environment
[apiInstance activateOperationEnvironmentWith:version
    operationalEnvironmentId:operationalEnvironmentId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfracloudResourcesApi()

var version = version_example; // {String} 

var operationalEnvironmentId = operationalEnvironmentId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class activateOperationEnvironmentExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfracloudResourcesApi();
            var version = version_example;  // String | 
            var operationalEnvironmentId = operationalEnvironmentId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Activate an Operational Environment
                apiInstance.activateOperationEnvironment(version, operationalEnvironmentId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfracloudResourcesApi.activateOperationEnvironment: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfracloudResourcesApi();
$version = version_example; // String | 
$operationalEnvironmentId = operationalEnvironmentId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->activateOperationEnvironment($version, $operationalEnvironmentId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfracloudResourcesApi->activateOperationEnvironment: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfracloudResourcesApi->new();
my $version = version_example; # String | 
my $operationalEnvironmentId = operationalEnvironmentId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->activateOperationEnvironment(version => $version, operationalEnvironmentId => $operationalEnvironmentId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfracloudResourcesApi->activateOperationEnvironment: $@\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.OnapsoinfracloudResourcesApi()
version = version_example # String | 
operationalEnvironmentId = operationalEnvironmentId_example # String | 
body = body_example # String |  (optional)

try: 
    # Activate an Operational Environment
    api_instance.activate_operation_environment(version, operationalEnvironmentId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfracloudResourcesApi->activateOperationEnvironment: %s\n" % e)

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

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

public class OnapsoinfracloudResourcesApiExample {

    public static void main(String[] args) {
        
        OnapsoinfracloudResourcesApi apiInstance = new OnapsoinfracloudResourcesApi();
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createOperationEnvironment(version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfracloudResourcesApi#createOperationEnvironment");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfracloudResourcesApi;

public class OnapsoinfracloudResourcesApiExample {

    public static void main(String[] args) {
        OnapsoinfracloudResourcesApi apiInstance = new OnapsoinfracloudResourcesApi();
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createOperationEnvironment(version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfracloudResourcesApi#createOperationEnvironment");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *body = body_example; //  (optional)

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

// Create an Operational Environment
[apiInstance createOperationEnvironmentWith:version
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfracloudResourcesApi()

var version = version_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class createOperationEnvironmentExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfracloudResourcesApi();
            var version = version_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Create an Operational Environment
                apiInstance.createOperationEnvironment(version, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfracloudResourcesApi.createOperationEnvironment: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfracloudResourcesApi();
$version = version_example; // String | 
$body = body_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::OnapsoinfracloudResourcesApi->new();
my $version = version_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->createOperationEnvironment(version => $version, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfracloudResourcesApi->createOperationEnvironment: $@\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.OnapsoinfracloudResourcesApi()
version = version_example # String | 
body = body_example # String |  (optional)

try: 
    # Create an Operational Environment
    api_instance.create_operation_environment(version, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfracloudResourcesApi->createOperationEnvironment: %s\n" % e)

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

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

public class OnapsoinfracloudResourcesApiExample {

    public static void main(String[] args) {
        
        OnapsoinfracloudResourcesApi apiInstance = new OnapsoinfracloudResourcesApi();
        String version = version_example; // String | 
        String operationalEnvironmentId = operationalEnvironmentId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deactivateOperationEnvironment(version, operationalEnvironmentId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfracloudResourcesApi#deactivateOperationEnvironment");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfracloudResourcesApi;

public class OnapsoinfracloudResourcesApiExample {

    public static void main(String[] args) {
        OnapsoinfracloudResourcesApi apiInstance = new OnapsoinfracloudResourcesApi();
        String version = version_example; // String | 
        String operationalEnvironmentId = operationalEnvironmentId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deactivateOperationEnvironment(version, operationalEnvironmentId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfracloudResourcesApi#deactivateOperationEnvironment");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *operationalEnvironmentId = operationalEnvironmentId_example; // 
String *body = body_example; //  (optional)

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

// Deactivate an Operational Environment
[apiInstance deactivateOperationEnvironmentWith:version
    operationalEnvironmentId:operationalEnvironmentId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfracloudResourcesApi()

var version = version_example; // {String} 

var operationalEnvironmentId = operationalEnvironmentId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class deactivateOperationEnvironmentExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfracloudResourcesApi();
            var version = version_example;  // String | 
            var operationalEnvironmentId = operationalEnvironmentId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Deactivate an Operational Environment
                apiInstance.deactivateOperationEnvironment(version, operationalEnvironmentId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfracloudResourcesApi.deactivateOperationEnvironment: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfracloudResourcesApi();
$version = version_example; // String | 
$operationalEnvironmentId = operationalEnvironmentId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->deactivateOperationEnvironment($version, $operationalEnvironmentId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfracloudResourcesApi->deactivateOperationEnvironment: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfracloudResourcesApi->new();
my $version = version_example; # String | 
my $operationalEnvironmentId = operationalEnvironmentId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->deactivateOperationEnvironment(version => $version, operationalEnvironmentId => $operationalEnvironmentId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfracloudResourcesApi->deactivateOperationEnvironment: $@\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.OnapsoinfracloudResourcesApi()
version = version_example # String | 
operationalEnvironmentId = operationalEnvironmentId_example # String | 
body = body_example # String |  (optional)

try: 
    # Deactivate an Operational Environment
    api_instance.deactivate_operation_environment(version, operationalEnvironmentId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfracloudResourcesApi->deactivateOperationEnvironment: %s\n" % e)

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

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

public class OnapsoinfracloudResourcesRequestsApiExample {

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

import io.swagger.client.api.OnapsoinfracloudResourcesRequestsApi;

public class OnapsoinfracloudResourcesRequestsApiExample {

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

String *version = version_example; // 

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

// Get status of an Operational Environment based on filter criteria
[apiInstance getOperationEnvironmentStatusFilterWith:version
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfracloudResourcesRequestsApi()

var version = version_example; // {String} 


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

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

namespace Example
{
    public class getOperationEnvironmentStatusFilterExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfracloudResourcesRequestsApi();
            var version = version_example;  // String | 

            try
            {
                // Get status of an Operational Environment based on filter criteria
                apiInstance.getOperationEnvironmentStatusFilter(version);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfracloudResourcesRequestsApi.getOperationEnvironmentStatusFilter: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfracloudResourcesRequestsApi();
$version = version_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::OnapsoinfracloudResourcesRequestsApi->new();
my $version = version_example; # String | 

eval { 
    $api_instance->getOperationEnvironmentStatusFilter(version => $version);
};
if ($@) {
    warn "Exception when calling OnapsoinfracloudResourcesRequestsApi->getOperationEnvironmentStatusFilter: $@\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.OnapsoinfracloudResourcesRequestsApi()
version = version_example # String | 

try: 
    # Get status of an Operational Environment based on filter criteria
    api_instance.get_operation_environment_status_filter(version)
except ApiException as e:
    print("Exception when calling OnapsoinfracloudResourcesRequestsApi->getOperationEnvironmentStatusFilter: %s\n" % e)

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

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

public class OnapsoinfracloudResourcesRequestsApiExample {

    public static void main(String[] args) {
        
        OnapsoinfracloudResourcesRequestsApi apiInstance = new OnapsoinfracloudResourcesRequestsApi();
        String requestId = requestId_example; // String | 
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.unlockOrchestrationRequestForReqId(requestId, version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfracloudResourcesRequestsApi#unlockOrchestrationRequestForReqId");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfracloudResourcesRequestsApi;

public class OnapsoinfracloudResourcesRequestsApiExample {

    public static void main(String[] args) {
        OnapsoinfracloudResourcesRequestsApi apiInstance = new OnapsoinfracloudResourcesRequestsApi();
        String requestId = requestId_example; // String | 
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.unlockOrchestrationRequestForReqId(requestId, version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfracloudResourcesRequestsApi#unlockOrchestrationRequestForReqId");
            e.printStackTrace();
        }
    }
}

String *requestId = requestId_example; // 
String *version = version_example; // 
String *body = body_example; //  (optional)

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

// Unlock CloudOrchestration requests for a specified requestId
[apiInstance unlockOrchestrationRequestForReqIdWith:requestId
    version:version
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfracloudResourcesRequestsApi()

var requestId = requestId_example; // {String} 

var version = version_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class unlockOrchestrationRequestForReqIdExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfracloudResourcesRequestsApi();
            var requestId = requestId_example;  // String | 
            var version = version_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Unlock CloudOrchestration requests for a specified requestId
                apiInstance.unlockOrchestrationRequestForReqId(requestId, version, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfracloudResourcesRequestsApi.unlockOrchestrationRequestForReqId: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfracloudResourcesRequestsApi();
$requestId = requestId_example; // String | 
$version = version_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->unlockOrchestrationRequestForReqId($requestId, $version, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfracloudResourcesRequestsApi->unlockOrchestrationRequestForReqId: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfracloudResourcesRequestsApi->new();
my $requestId = requestId_example; # String | 
my $version = version_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->unlockOrchestrationRequestForReqId(requestId => $requestId, version => $version, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfracloudResourcesRequestsApi->unlockOrchestrationRequestForReqId: $@\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.OnapsoinfracloudResourcesRequestsApi()
requestId = requestId_example # String | 
version = version_example # String | 
body = body_example # String |  (optional)

try: 
    # Unlock CloudOrchestration requests for a specified requestId
    api_instance.unlock_orchestration_request_for_req_id(requestId, version, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfracloudResourcesRequestsApi->unlockOrchestrationRequestForReqId: %s\n" % e)

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

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

public class OnapsoinframodelDistributionsApiExample {

    public static void main(String[] args) {
        
        OnapsoinframodelDistributionsApi apiInstance = new OnapsoinframodelDistributionsApi();
        String version = version_example; // String | 
        String distributionId = distributionId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.updateModelDistributionStatus(version, distributionId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinframodelDistributionsApi#updateModelDistributionStatus");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinframodelDistributionsApi;

public class OnapsoinframodelDistributionsApiExample {

    public static void main(String[] args) {
        OnapsoinframodelDistributionsApi apiInstance = new OnapsoinframodelDistributionsApi();
        String version = version_example; // String | 
        String distributionId = distributionId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.updateModelDistributionStatus(version, distributionId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinframodelDistributionsApi#updateModelDistributionStatus");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *distributionId = distributionId_example; // 
String *body = body_example; //  (optional)

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

// Update model distribution status
[apiInstance updateModelDistributionStatusWith:version
    distributionId:distributionId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinframodelDistributionsApi()

var version = version_example; // {String} 

var distributionId = distributionId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class updateModelDistributionStatusExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinframodelDistributionsApi();
            var version = version_example;  // String | 
            var distributionId = distributionId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Update model distribution status
                apiInstance.updateModelDistributionStatus(version, distributionId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinframodelDistributionsApi.updateModelDistributionStatus: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinframodelDistributionsApi();
$version = version_example; // String | 
$distributionId = distributionId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->updateModelDistributionStatus($version, $distributionId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinframodelDistributionsApi->updateModelDistributionStatus: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinframodelDistributionsApi->new();
my $version = version_example; # String | 
my $distributionId = distributionId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->updateModelDistributionStatus(version => $version, distributionId => $distributionId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinframodelDistributionsApi->updateModelDistributionStatus: $@\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.OnapsoinframodelDistributionsApi()
version = version_example # String | 
distributionId = distributionId_example # String | 
body = body_example # String |  (optional)

try: 
    # Update model distribution status
    api_instance.update_model_distribution_status(version, distributionId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinframodelDistributionsApi->updateModelDistributionStatus: %s\n" % e)

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

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

public class OnapsoinfraorchestrationRequestsApiExample {

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

import io.swagger.client.api.OnapsoinfraorchestrationRequestsApi;

public class OnapsoinfraorchestrationRequestsApiExample {

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

String *version = version_example; // 

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

// Find Orchestrated Requests for a URI Information
[apiInstance getOrchestrationRequestWith:version
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraorchestrationRequestsApi()

var version = version_example; // {String} 


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

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

namespace Example
{
    public class getOrchestrationRequestExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraorchestrationRequestsApi();
            var version = version_example;  // String | 

            try
            {
                // Find Orchestrated Requests for a URI Information
                apiInstance.getOrchestrationRequest(version);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraorchestrationRequestsApi.getOrchestrationRequest: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraorchestrationRequestsApi();
$version = version_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraorchestrationRequestsApi->new();
my $version = version_example; # String | 

eval { 
    $api_instance->getOrchestrationRequest(version => $version);
};
if ($@) {
    warn "Exception when calling OnapsoinfraorchestrationRequestsApi->getOrchestrationRequest: $@\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.OnapsoinfraorchestrationRequestsApi()
version = version_example # String | 

try: 
    # Find Orchestrated Requests for a URI Information
    api_instance.get_orchestration_request(version)
except ApiException as e:
    print("Exception when calling OnapsoinfraorchestrationRequestsApi->getOrchestrationRequest: %s\n" % e)

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

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

public class OnapsoinfraorchestrationRequestsApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraorchestrationRequestsApi apiInstance = new OnapsoinfraorchestrationRequestsApi();
        String requestId = requestId_example; // String | 
        String version = version_example; // String | 
        try {
            apiInstance.getOrchestrationRequestForReqId(requestId, version);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationRequestsApi#getOrchestrationRequestForReqId");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraorchestrationRequestsApi;

public class OnapsoinfraorchestrationRequestsApiExample {

    public static void main(String[] args) {
        OnapsoinfraorchestrationRequestsApi apiInstance = new OnapsoinfraorchestrationRequestsApi();
        String requestId = requestId_example; // String | 
        String version = version_example; // String | 
        try {
            apiInstance.getOrchestrationRequestForReqId(requestId, version);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationRequestsApi#getOrchestrationRequestForReqId");
            e.printStackTrace();
        }
    }
}

String *requestId = requestId_example; // 
String *version = version_example; // 

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

// Find Orchestrated Requests for a given requestId
[apiInstance getOrchestrationRequestForReqIdWith:requestId
    version:version
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraorchestrationRequestsApi()

var requestId = requestId_example; // {String} 

var version = version_example; // {String} 


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

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

namespace Example
{
    public class getOrchestrationRequestForReqIdExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraorchestrationRequestsApi();
            var requestId = requestId_example;  // String | 
            var version = version_example;  // String | 

            try
            {
                // Find Orchestrated Requests for a given requestId
                apiInstance.getOrchestrationRequestForReqId(requestId, version);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraorchestrationRequestsApi.getOrchestrationRequestForReqId: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraorchestrationRequestsApi();
$requestId = requestId_example; // String | 
$version = version_example; // String | 

try {
    $api_instance->getOrchestrationRequestForReqId($requestId, $version);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraorchestrationRequestsApi->getOrchestrationRequestForReqId: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraorchestrationRequestsApi->new();
my $requestId = requestId_example; # String | 
my $version = version_example; # String | 

eval { 
    $api_instance->getOrchestrationRequestForReqId(requestId => $requestId, version => $version);
};
if ($@) {
    warn "Exception when calling OnapsoinfraorchestrationRequestsApi->getOrchestrationRequestForReqId: $@\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.OnapsoinfraorchestrationRequestsApi()
requestId = requestId_example # String | 
version = version_example # String | 

try: 
    # Find Orchestrated Requests for a given requestId
    api_instance.get_orchestration_request_for_req_id(requestId, version)
except ApiException as e:
    print("Exception when calling OnapsoinfraorchestrationRequestsApi->getOrchestrationRequestForReqId: %s\n" % e)

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

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

public class OnapsoinfraorchestrationRequestsApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraorchestrationRequestsApi apiInstance = new OnapsoinfraorchestrationRequestsApi();
        String requestId = requestId_example; // String | 
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.unlockOrchestrationRequest(requestId, version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationRequestsApi#unlockOrchestrationRequest");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraorchestrationRequestsApi;

public class OnapsoinfraorchestrationRequestsApiExample {

    public static void main(String[] args) {
        OnapsoinfraorchestrationRequestsApi apiInstance = new OnapsoinfraorchestrationRequestsApi();
        String requestId = requestId_example; // String | 
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.unlockOrchestrationRequest(requestId, version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationRequestsApi#unlockOrchestrationRequest");
            e.printStackTrace();
        }
    }
}

String *requestId = requestId_example; // 
String *version = version_example; // 
String *body = body_example; //  (optional)

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

// Unlock Orchestrated Requests for a given requestId
[apiInstance unlockOrchestrationRequestWith:requestId
    version:version
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraorchestrationRequestsApi()

var requestId = requestId_example; // {String} 

var version = version_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class unlockOrchestrationRequestExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraorchestrationRequestsApi();
            var requestId = requestId_example;  // String | 
            var version = version_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Unlock Orchestrated Requests for a given requestId
                apiInstance.unlockOrchestrationRequest(requestId, version, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraorchestrationRequestsApi.unlockOrchestrationRequest: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraorchestrationRequestsApi();
$requestId = requestId_example; // String | 
$version = version_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->unlockOrchestrationRequest($requestId, $version, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraorchestrationRequestsApi->unlockOrchestrationRequest: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraorchestrationRequestsApi->new();
my $requestId = requestId_example; # String | 
my $version = version_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->unlockOrchestrationRequest(requestId => $requestId, version => $version, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraorchestrationRequestsApi->unlockOrchestrationRequest: $@\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.OnapsoinfraorchestrationRequestsApi()
requestId = requestId_example # String | 
version = version_example # String | 
body = body_example # String |  (optional)

try: 
    # Unlock Orchestrated Requests for a given requestId
    api_instance.unlock_orchestration_request(requestId, version, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraorchestrationRequestsApi->unlockOrchestrationRequest: %s\n" % e)

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

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

public class OnapsoinfraorchestrationTasksApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraorchestrationTasksApi apiInstance = new OnapsoinfraorchestrationTasksApi();
        String taskId = taskId_example; // String | 
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.abortOrchestrationTask(taskId, version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationTasksApi#abortOrchestrationTask");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraorchestrationTasksApi;

public class OnapsoinfraorchestrationTasksApiExample {

    public static void main(String[] args) {
        OnapsoinfraorchestrationTasksApi apiInstance = new OnapsoinfraorchestrationTasksApi();
        String taskId = taskId_example; // String | 
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.abortOrchestrationTask(taskId, version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationTasksApi#abortOrchestrationTask");
            e.printStackTrace();
        }
    }
}

String *taskId = taskId_example; // 
String *version = version_example; // 
String *body = body_example; //  (optional)

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

// abort orchestrationTask for a given taskId
[apiInstance abortOrchestrationTaskWith:taskId
    version:version
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraorchestrationTasksApi()

var taskId = taskId_example; // {String} 

var version = version_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class abortOrchestrationTaskExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraorchestrationTasksApi();
            var taskId = taskId_example;  // String | 
            var version = version_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // abort orchestrationTask for a given taskId
                apiInstance.abortOrchestrationTask(taskId, version, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraorchestrationTasksApi.abortOrchestrationTask: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraorchestrationTasksApi();
$taskId = taskId_example; // String | 
$version = version_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->abortOrchestrationTask($taskId, $version, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraorchestrationTasksApi->abortOrchestrationTask: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraorchestrationTasksApi->new();
my $taskId = taskId_example; # String | 
my $version = version_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->abortOrchestrationTask(taskId => $taskId, version => $version, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraorchestrationTasksApi->abortOrchestrationTask: $@\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.OnapsoinfraorchestrationTasksApi()
taskId = taskId_example # String | 
version = version_example # String | 
body = body_example # String |  (optional)

try: 
    # abort orchestrationTask for a given taskId
    api_instance.abort_orchestration_task(taskId, version, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraorchestrationTasksApi->abortOrchestrationTask: %s\n" % e)

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

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

public class OnapsoinfraorchestrationTasksApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraorchestrationTasksApi apiInstance = new OnapsoinfraorchestrationTasksApi();
        String taskId = taskId_example; // String | 
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.commitOrchestrationTask(taskId, version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationTasksApi#commitOrchestrationTask");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraorchestrationTasksApi;

public class OnapsoinfraorchestrationTasksApiExample {

    public static void main(String[] args) {
        OnapsoinfraorchestrationTasksApi apiInstance = new OnapsoinfraorchestrationTasksApi();
        String taskId = taskId_example; // String | 
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.commitOrchestrationTask(taskId, version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationTasksApi#commitOrchestrationTask");
            e.printStackTrace();
        }
    }
}

String *taskId = taskId_example; // 
String *version = version_example; // 
String *body = body_example; //  (optional)

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

// commit orchestrationTask for a given taskId
[apiInstance commitOrchestrationTaskWith:taskId
    version:version
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraorchestrationTasksApi()

var taskId = taskId_example; // {String} 

var version = version_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class commitOrchestrationTaskExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraorchestrationTasksApi();
            var taskId = taskId_example;  // String | 
            var version = version_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // commit orchestrationTask for a given taskId
                apiInstance.commitOrchestrationTask(taskId, version, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraorchestrationTasksApi.commitOrchestrationTask: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraorchestrationTasksApi();
$taskId = taskId_example; // String | 
$version = version_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->commitOrchestrationTask($taskId, $version, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraorchestrationTasksApi->commitOrchestrationTask: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraorchestrationTasksApi->new();
my $taskId = taskId_example; # String | 
my $version = version_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->commitOrchestrationTask(taskId => $taskId, version => $version, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraorchestrationTasksApi->commitOrchestrationTask: $@\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.OnapsoinfraorchestrationTasksApi()
taskId = taskId_example # String | 
version = version_example # String | 
body = body_example # String |  (optional)

try: 
    # commit orchestrationTask for a given taskId
    api_instance.commit_orchestration_task(taskId, version, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraorchestrationTasksApi->commitOrchestrationTask: %s\n" % e)

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

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

public class OnapsoinfraorchestrationTasksApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraorchestrationTasksApi apiInstance = new OnapsoinfraorchestrationTasksApi();
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createOrchestrationTask(version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationTasksApi#createOrchestrationTask");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraorchestrationTasksApi;

public class OnapsoinfraorchestrationTasksApiExample {

    public static void main(String[] args) {
        OnapsoinfraorchestrationTasksApi apiInstance = new OnapsoinfraorchestrationTasksApi();
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createOrchestrationTask(version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationTasksApi#createOrchestrationTask");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *body = body_example; //  (optional)

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

// Create an orchestrationTask
[apiInstance createOrchestrationTaskWith:version
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraorchestrationTasksApi()

var version = version_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class createOrchestrationTaskExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraorchestrationTasksApi();
            var version = version_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Create an orchestrationTask
                apiInstance.createOrchestrationTask(version, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraorchestrationTasksApi.createOrchestrationTask: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraorchestrationTasksApi();
$version = version_example; // String | 
$body = body_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraorchestrationTasksApi->new();
my $version = version_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->createOrchestrationTask(version => $version, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraorchestrationTasksApi->createOrchestrationTask: $@\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.OnapsoinfraorchestrationTasksApi()
version = version_example # String | 
body = body_example # String |  (optional)

try: 
    # Create an orchestrationTask
    api_instance.create_orchestration_task(version, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraorchestrationTasksApi->createOrchestrationTask: %s\n" % e)

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

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

public class OnapsoinfraorchestrationTasksApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraorchestrationTasksApi apiInstance = new OnapsoinfraorchestrationTasksApi();
        String taskId = taskId_example; // String | 
        String version = version_example; // String | 
        try {
            apiInstance.deleteOrchestrationTask(taskId, version);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationTasksApi#deleteOrchestrationTask");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraorchestrationTasksApi;

public class OnapsoinfraorchestrationTasksApiExample {

    public static void main(String[] args) {
        OnapsoinfraorchestrationTasksApi apiInstance = new OnapsoinfraorchestrationTasksApi();
        String taskId = taskId_example; // String | 
        String version = version_example; // String | 
        try {
            apiInstance.deleteOrchestrationTask(taskId, version);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationTasksApi#deleteOrchestrationTask");
            e.printStackTrace();
        }
    }
}

String *taskId = taskId_example; // 
String *version = version_example; // 

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

// delete orchestrationTask for a given taskId
[apiInstance deleteOrchestrationTaskWith:taskId
    version:version
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraorchestrationTasksApi()

var taskId = taskId_example; // {String} 

var version = version_example; // {String} 


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

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

namespace Example
{
    public class deleteOrchestrationTaskExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraorchestrationTasksApi();
            var taskId = taskId_example;  // String | 
            var version = version_example;  // String | 

            try
            {
                // delete orchestrationTask for a given taskId
                apiInstance.deleteOrchestrationTask(taskId, version);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraorchestrationTasksApi.deleteOrchestrationTask: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraorchestrationTasksApi();
$taskId = taskId_example; // String | 
$version = version_example; // String | 

try {
    $api_instance->deleteOrchestrationTask($taskId, $version);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraorchestrationTasksApi->deleteOrchestrationTask: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraorchestrationTasksApi->new();
my $taskId = taskId_example; # String | 
my $version = version_example; # String | 

eval { 
    $api_instance->deleteOrchestrationTask(taskId => $taskId, version => $version);
};
if ($@) {
    warn "Exception when calling OnapsoinfraorchestrationTasksApi->deleteOrchestrationTask: $@\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.OnapsoinfraorchestrationTasksApi()
taskId = taskId_example # String | 
version = version_example # String | 

try: 
    # delete orchestrationTask for a given taskId
    api_instance.delete_orchestration_task(taskId, version)
except ApiException as e:
    print("Exception when calling OnapsoinfraorchestrationTasksApi->deleteOrchestrationTask: %s\n" % e)

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

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

public class OnapsoinfraorchestrationTasksApiExample {

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

import io.swagger.client.api.OnapsoinfraorchestrationTasksApi;

public class OnapsoinfraorchestrationTasksApiExample {

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

String *version = version_example; // 

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

// Get all orchestrationTasks
[apiInstance getAllOrchestrationTasksWith:version
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraorchestrationTasksApi()

var version = version_example; // {String} 


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

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

namespace Example
{
    public class getAllOrchestrationTasksExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraorchestrationTasksApi();
            var version = version_example;  // String | 

            try
            {
                // Get all orchestrationTasks
                apiInstance.getAllOrchestrationTasks(version);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraorchestrationTasksApi.getAllOrchestrationTasks: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraorchestrationTasksApi();
$version = version_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraorchestrationTasksApi->new();
my $version = version_example; # String | 

eval { 
    $api_instance->getAllOrchestrationTasks(version => $version);
};
if ($@) {
    warn "Exception when calling OnapsoinfraorchestrationTasksApi->getAllOrchestrationTasks: $@\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.OnapsoinfraorchestrationTasksApi()
version = version_example # String | 

try: 
    # Get all orchestrationTasks
    api_instance.get_all_orchestration_tasks(version)
except ApiException as e:
    print("Exception when calling OnapsoinfraorchestrationTasksApi->getAllOrchestrationTasks: %s\n" % e)

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

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

public class OnapsoinfraorchestrationTasksApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraorchestrationTasksApi apiInstance = new OnapsoinfraorchestrationTasksApi();
        String taskId = taskId_example; // String | 
        String version = version_example; // String | 
        try {
            apiInstance.getOrchestrationTask(taskId, version);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationTasksApi#getOrchestrationTask");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraorchestrationTasksApi;

public class OnapsoinfraorchestrationTasksApiExample {

    public static void main(String[] args) {
        OnapsoinfraorchestrationTasksApi apiInstance = new OnapsoinfraorchestrationTasksApi();
        String taskId = taskId_example; // String | 
        String version = version_example; // String | 
        try {
            apiInstance.getOrchestrationTask(taskId, version);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationTasksApi#getOrchestrationTask");
            e.printStackTrace();
        }
    }
}

String *taskId = taskId_example; // 
String *version = version_example; // 

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

// Get orchestrationTask for a given taskId
[apiInstance getOrchestrationTaskWith:taskId
    version:version
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraorchestrationTasksApi()

var taskId = taskId_example; // {String} 

var version = version_example; // {String} 


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

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

namespace Example
{
    public class getOrchestrationTaskExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraorchestrationTasksApi();
            var taskId = taskId_example;  // String | 
            var version = version_example;  // String | 

            try
            {
                // Get orchestrationTask for a given taskId
                apiInstance.getOrchestrationTask(taskId, version);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraorchestrationTasksApi.getOrchestrationTask: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraorchestrationTasksApi();
$taskId = taskId_example; // String | 
$version = version_example; // String | 

try {
    $api_instance->getOrchestrationTask($taskId, $version);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraorchestrationTasksApi->getOrchestrationTask: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraorchestrationTasksApi->new();
my $taskId = taskId_example; # String | 
my $version = version_example; # String | 

eval { 
    $api_instance->getOrchestrationTask(taskId => $taskId, version => $version);
};
if ($@) {
    warn "Exception when calling OnapsoinfraorchestrationTasksApi->getOrchestrationTask: $@\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.OnapsoinfraorchestrationTasksApi()
taskId = taskId_example # String | 
version = version_example # String | 

try: 
    # Get orchestrationTask for a given taskId
    api_instance.get_orchestration_task(taskId, version)
except ApiException as e:
    print("Exception when calling OnapsoinfraorchestrationTasksApi->getOrchestrationTask: %s\n" % e)

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

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

public class OnapsoinfraorchestrationTasksApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraorchestrationTasksApi apiInstance = new OnapsoinfraorchestrationTasksApi();
        String taskId = taskId_example; // String | 
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.updateOrchestrationTask(taskId, version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationTasksApi#updateOrchestrationTask");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraorchestrationTasksApi;

public class OnapsoinfraorchestrationTasksApiExample {

    public static void main(String[] args) {
        OnapsoinfraorchestrationTasksApi apiInstance = new OnapsoinfraorchestrationTasksApi();
        String taskId = taskId_example; // String | 
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.updateOrchestrationTask(taskId, version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraorchestrationTasksApi#updateOrchestrationTask");
            e.printStackTrace();
        }
    }
}

String *taskId = taskId_example; // 
String *version = version_example; // 
String *body = body_example; //  (optional)

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

// update orchestrationTask for a given taskId
[apiInstance updateOrchestrationTaskWith:taskId
    version:version
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraorchestrationTasksApi()

var taskId = taskId_example; // {String} 

var version = version_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class updateOrchestrationTaskExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraorchestrationTasksApi();
            var taskId = taskId_example;  // String | 
            var version = version_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // update orchestrationTask for a given taskId
                apiInstance.updateOrchestrationTask(taskId, version, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraorchestrationTasksApi.updateOrchestrationTask: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraorchestrationTasksApi();
$taskId = taskId_example; // String | 
$version = version_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->updateOrchestrationTask($taskId, $version, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraorchestrationTasksApi->updateOrchestrationTask: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraorchestrationTasksApi->new();
my $taskId = taskId_example; # String | 
my $version = version_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->updateOrchestrationTask(taskId => $taskId, version => $version, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraorchestrationTasksApi->updateOrchestrationTask: $@\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.OnapsoinfraorchestrationTasksApi()
taskId = taskId_example # String | 
version = version_example # String | 
body = body_example # String |  (optional)

try: 
    # update orchestrationTask for a given taskId
    api_instance.update_orchestration_task(taskId, version, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraorchestrationTasksApi->updateOrchestrationTask: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String configurationInstanceId = configurationInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.activatePort(version, serviceInstanceId, configurationInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#activatePort");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String configurationInstanceId = configurationInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.activatePort(version, serviceInstanceId, configurationInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#activatePort");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *configurationInstanceId = configurationInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Activate Port Mirroring
[apiInstance activatePortWith:version
    serviceInstanceId:serviceInstanceId
    configurationInstanceId:configurationInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var configurationInstanceId = configurationInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class activatePortExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var configurationInstanceId = configurationInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Activate Port Mirroring
                apiInstance.activatePort(version, serviceInstanceId, configurationInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.activatePort: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$configurationInstanceId = configurationInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->activatePort($version, $serviceInstanceId, $configurationInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->activatePort: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $configurationInstanceId = configurationInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->activatePort(version => $version, serviceInstanceId => $serviceInstanceId, configurationInstanceId => $configurationInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->activatePort: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
configurationInstanceId = configurationInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Activate Port Mirroring
    api_instance.activate_port(version, serviceInstanceId, configurationInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->activatePort: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.activateServiceInstance(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#activateServiceInstance");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.activateServiceInstance(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#activateServiceInstance");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Activate provided Service Instance
[apiInstance activateServiceInstanceWith:version
    serviceInstanceId:serviceInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class activateServiceInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Activate provided Service Instance
                apiInstance.activateServiceInstance(version, serviceInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.activateServiceInstance: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->activateServiceInstance($version, $serviceInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->activateServiceInstance: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->activateServiceInstance(version => $version, serviceInstanceId => $serviceInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->activateServiceInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Activate provided Service Instance
    api_instance.activate_service_instance(version, serviceInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->activateServiceInstance: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.addRelationships(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#addRelationships");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.addRelationships(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#addRelationships");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Add Relationships to a Service Instance
[apiInstance addRelationshipsWith:version
    serviceInstanceId:serviceInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class addRelationshipsExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Add Relationships to a Service Instance
                apiInstance.addRelationships(version, serviceInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.addRelationships: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->addRelationships($version, $serviceInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->addRelationships: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->addRelationships(version => $version, serviceInstanceId => $serviceInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->addRelationships: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Add Relationships to a Service Instance
    api_instance.add_relationships(version, serviceInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->addRelationships: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.applyUpdatedConfig(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#applyUpdatedConfig");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.applyUpdatedConfig(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#applyUpdatedConfig");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *vnfInstanceId = vnfInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Apply updated configuration
[apiInstance applyUpdatedConfigWith:version
    serviceInstanceId:serviceInstanceId
    vnfInstanceId:vnfInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var vnfInstanceId = vnfInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class applyUpdatedConfigExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var vnfInstanceId = vnfInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Apply updated configuration
                apiInstance.applyUpdatedConfig(version, serviceInstanceId, vnfInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.applyUpdatedConfig: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$vnfInstanceId = vnfInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->applyUpdatedConfig($version, $serviceInstanceId, $vnfInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->applyUpdatedConfig: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $vnfInstanceId = vnfInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->applyUpdatedConfig(version => $version, serviceInstanceId => $serviceInstanceId, vnfInstanceId => $vnfInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->applyUpdatedConfig: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
vnfInstanceId = vnfInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Apply updated configuration
    api_instance.apply_updated_config(version, serviceInstanceId, vnfInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->applyUpdatedConfig: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.assignServiceInstance(version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#assignServiceInstance");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.assignServiceInstance(version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#assignServiceInstance");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *body = body_example; //  (optional)

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

// Assign Service Instance
[apiInstance assignServiceInstanceWith:version
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class assignServiceInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Assign Service Instance
                apiInstance.assignServiceInstance(version, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.assignServiceInstance: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$body = body_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->assignServiceInstance(version => $version, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->assignServiceInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
body = body_example # String |  (optional)

try: 
    # Assign Service Instance
    api_instance.assign_service_instance(version, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->assignServiceInstance: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createNetworkInstance(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#createNetworkInstance");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createNetworkInstance(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#createNetworkInstance");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Create NetworkInstance on a specified version and serviceInstance 
[apiInstance createNetworkInstanceWith:version
    serviceInstanceId:serviceInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class createNetworkInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Create NetworkInstance on a specified version and serviceInstance 
                apiInstance.createNetworkInstance(version, serviceInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.createNetworkInstance: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->createNetworkInstance($version, $serviceInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->createNetworkInstance: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->createNetworkInstance(version => $version, serviceInstanceId => $serviceInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->createNetworkInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Create NetworkInstance on a specified version and serviceInstance 
    api_instance.create_network_instance(version, serviceInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->createNetworkInstance: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createPortConfiguration(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#createPortConfiguration");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createPortConfiguration(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#createPortConfiguration");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Create Port Mirroring Configuration
[apiInstance createPortConfigurationWith:version
    serviceInstanceId:serviceInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class createPortConfigurationExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Create Port Mirroring Configuration
                apiInstance.createPortConfiguration(version, serviceInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.createPortConfiguration: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->createPortConfiguration($version, $serviceInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->createPortConfiguration: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->createPortConfiguration(version => $version, serviceInstanceId => $serviceInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->createPortConfiguration: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Create Port Mirroring Configuration
    api_instance.create_port_configuration(version, serviceInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->createPortConfiguration: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createServiceInstance(version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#createServiceInstance");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createServiceInstance(version, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#createServiceInstance");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *body = body_example; //  (optional)

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

// Create a Service Instance on a version provided
[apiInstance createServiceInstanceWith:version
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class createServiceInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Create a Service Instance on a version provided
                apiInstance.createServiceInstance(version, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.createServiceInstance: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$body = body_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->createServiceInstance(version => $version, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->createServiceInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
body = body_example # String |  (optional)

try: 
    # Create a Service Instance on a version provided
    api_instance.create_service_instance(version, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->createServiceInstance: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createVfModuleInstance(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#createVfModuleInstance");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createVfModuleInstance(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#createVfModuleInstance");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *vnfInstanceId = vnfInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Create VfModule on a specified version, serviceInstance and vnfInstance
[apiInstance createVfModuleInstanceWith:version
    serviceInstanceId:serviceInstanceId
    vnfInstanceId:vnfInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var vnfInstanceId = vnfInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class createVfModuleInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var vnfInstanceId = vnfInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Create VfModule on a specified version, serviceInstance and vnfInstance
                apiInstance.createVfModuleInstance(version, serviceInstanceId, vnfInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.createVfModuleInstance: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$vnfInstanceId = vnfInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->createVfModuleInstance($version, $serviceInstanceId, $vnfInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->createVfModuleInstance: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $vnfInstanceId = vnfInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->createVfModuleInstance(version => $version, serviceInstanceId => $serviceInstanceId, vnfInstanceId => $vnfInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->createVfModuleInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
vnfInstanceId = vnfInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Create VfModule on a specified version, serviceInstance and vnfInstance
    api_instance.create_vf_module_instance(version, serviceInstanceId, vnfInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->createVfModuleInstance: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createVnfInstance(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#createVnfInstance");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createVnfInstance(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#createVnfInstance");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Create VNF on a specified version and serviceInstance
[apiInstance createVnfInstanceWith:version
    serviceInstanceId:serviceInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class createVnfInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Create VNF on a specified version and serviceInstance
                apiInstance.createVnfInstance(version, serviceInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.createVnfInstance: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->createVnfInstance($version, $serviceInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->createVnfInstance: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->createVnfInstance(version => $version, serviceInstanceId => $serviceInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->createVnfInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Create VNF on a specified version and serviceInstance
    api_instance.create_vnf_instance(version, serviceInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->createVnfInstance: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createVolumeGroupInstance(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#createVolumeGroupInstance");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.createVolumeGroupInstance(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#createVolumeGroupInstance");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *vnfInstanceId = vnfInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Create VolumeGroup on a specified version, serviceInstance, vnfInstance
[apiInstance createVolumeGroupInstanceWith:version
    serviceInstanceId:serviceInstanceId
    vnfInstanceId:vnfInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var vnfInstanceId = vnfInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class createVolumeGroupInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var vnfInstanceId = vnfInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Create VolumeGroup on a specified version, serviceInstance, vnfInstance
                apiInstance.createVolumeGroupInstance(version, serviceInstanceId, vnfInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.createVolumeGroupInstance: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$vnfInstanceId = vnfInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->createVolumeGroupInstance($version, $serviceInstanceId, $vnfInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->createVolumeGroupInstance: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $vnfInstanceId = vnfInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->createVolumeGroupInstance(version => $version, serviceInstanceId => $serviceInstanceId, vnfInstanceId => $vnfInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->createVolumeGroupInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
vnfInstanceId = vnfInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Create VolumeGroup on a specified version, serviceInstance, vnfInstance
    api_instance.create_volume_group_instance(version, serviceInstanceId, vnfInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->createVolumeGroupInstance: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String vfmoduleInstanceId = vfmoduleInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deactivateAndCloudDeleteVfModuleInstance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deactivateAndCloudDeleteVfModuleInstance");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String vfmoduleInstanceId = vfmoduleInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deactivateAndCloudDeleteVfModuleInstance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deactivateAndCloudDeleteVfModuleInstance");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *vnfInstanceId = vnfInstanceId_example; // 
String *vfmoduleInstanceId = vfmoduleInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Deactivate and Cloud Delete VfModule instance
[apiInstance deactivateAndCloudDeleteVfModuleInstanceWith:version
    serviceInstanceId:serviceInstanceId
    vnfInstanceId:vnfInstanceId
    vfmoduleInstanceId:vfmoduleInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var vnfInstanceId = vnfInstanceId_example; // {String} 

var vfmoduleInstanceId = vfmoduleInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class deactivateAndCloudDeleteVfModuleInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var vnfInstanceId = vnfInstanceId_example;  // String | 
            var vfmoduleInstanceId = vfmoduleInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Deactivate and Cloud Delete VfModule instance
                apiInstance.deactivateAndCloudDeleteVfModuleInstance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.deactivateAndCloudDeleteVfModuleInstance: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$vnfInstanceId = vnfInstanceId_example; // String | 
$vfmoduleInstanceId = vfmoduleInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->deactivateAndCloudDeleteVfModuleInstance($version, $serviceInstanceId, $vnfInstanceId, $vfmoduleInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->deactivateAndCloudDeleteVfModuleInstance: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $vnfInstanceId = vnfInstanceId_example; # String | 
my $vfmoduleInstanceId = vfmoduleInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->deactivateAndCloudDeleteVfModuleInstance(version => $version, serviceInstanceId => $serviceInstanceId, vnfInstanceId => $vnfInstanceId, vfmoduleInstanceId => $vfmoduleInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->deactivateAndCloudDeleteVfModuleInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
vnfInstanceId = vnfInstanceId_example # String | 
vfmoduleInstanceId = vfmoduleInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Deactivate and Cloud Delete VfModule instance
    api_instance.deactivate_and_cloud_delete_vf_module_instance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->deactivateAndCloudDeleteVfModuleInstance: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String configurationInstanceId = configurationInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deactivatePort(version, serviceInstanceId, configurationInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deactivatePort");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String configurationInstanceId = configurationInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deactivatePort(version, serviceInstanceId, configurationInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deactivatePort");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *configurationInstanceId = configurationInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Deactivate Port Mirroring
[apiInstance deactivatePortWith:version
    serviceInstanceId:serviceInstanceId
    configurationInstanceId:configurationInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var configurationInstanceId = configurationInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class deactivatePortExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var configurationInstanceId = configurationInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Deactivate Port Mirroring
                apiInstance.deactivatePort(version, serviceInstanceId, configurationInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.deactivatePort: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$configurationInstanceId = configurationInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->deactivatePort($version, $serviceInstanceId, $configurationInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->deactivatePort: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $configurationInstanceId = configurationInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->deactivatePort(version => $version, serviceInstanceId => $serviceInstanceId, configurationInstanceId => $configurationInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->deactivatePort: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
configurationInstanceId = configurationInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Deactivate Port Mirroring
    api_instance.deactivate_port(version, serviceInstanceId, configurationInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->deactivatePort: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deactivateServiceInstance(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deactivateServiceInstance");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deactivateServiceInstance(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deactivateServiceInstance");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Deactivate provided Service Instance
[apiInstance deactivateServiceInstanceWith:version
    serviceInstanceId:serviceInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class deactivateServiceInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Deactivate provided Service Instance
                apiInstance.deactivateServiceInstance(version, serviceInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.deactivateServiceInstance: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->deactivateServiceInstance($version, $serviceInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->deactivateServiceInstance: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->deactivateServiceInstance(version => $version, serviceInstanceId => $serviceInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->deactivateServiceInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Deactivate provided Service Instance
    api_instance.deactivate_service_instance(version, serviceInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->deactivateServiceInstance: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String networkInstanceId = networkInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deleteNetworkInstance(version, serviceInstanceId, networkInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deleteNetworkInstance");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String networkInstanceId = networkInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deleteNetworkInstance(version, serviceInstanceId, networkInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deleteNetworkInstance");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *networkInstanceId = networkInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Delete provided Network instance
[apiInstance deleteNetworkInstanceWith:version
    serviceInstanceId:serviceInstanceId
    networkInstanceId:networkInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var networkInstanceId = networkInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class deleteNetworkInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var networkInstanceId = networkInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Delete provided Network instance
                apiInstance.deleteNetworkInstance(version, serviceInstanceId, networkInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.deleteNetworkInstance: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$networkInstanceId = networkInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->deleteNetworkInstance($version, $serviceInstanceId, $networkInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->deleteNetworkInstance: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $networkInstanceId = networkInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->deleteNetworkInstance(version => $version, serviceInstanceId => $serviceInstanceId, networkInstanceId => $networkInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->deleteNetworkInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
networkInstanceId = networkInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Delete provided Network instance
    api_instance.delete_network_instance(version, serviceInstanceId, networkInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->deleteNetworkInstance: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String configurationInstanceId = configurationInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deletePortConfiguration(version, serviceInstanceId, configurationInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deletePortConfiguration");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String configurationInstanceId = configurationInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deletePortConfiguration(version, serviceInstanceId, configurationInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deletePortConfiguration");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *configurationInstanceId = configurationInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Delete provided Port
[apiInstance deletePortConfigurationWith:version
    serviceInstanceId:serviceInstanceId
    configurationInstanceId:configurationInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var configurationInstanceId = configurationInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class deletePortConfigurationExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var configurationInstanceId = configurationInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Delete provided Port
                apiInstance.deletePortConfiguration(version, serviceInstanceId, configurationInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.deletePortConfiguration: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$configurationInstanceId = configurationInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->deletePortConfiguration($version, $serviceInstanceId, $configurationInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->deletePortConfiguration: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $configurationInstanceId = configurationInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->deletePortConfiguration(version => $version, serviceInstanceId => $serviceInstanceId, configurationInstanceId => $configurationInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->deletePortConfiguration: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
configurationInstanceId = configurationInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Delete provided Port
    api_instance.delete_port_configuration(version, serviceInstanceId, configurationInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->deletePortConfiguration: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deleteServiceInstance(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deleteServiceInstance");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deleteServiceInstance(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deleteServiceInstance");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Delete provided Service Instance
[apiInstance deleteServiceInstanceWith:version
    serviceInstanceId:serviceInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class deleteServiceInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Delete provided Service Instance
                apiInstance.deleteServiceInstance(version, serviceInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.deleteServiceInstance: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->deleteServiceInstance($version, $serviceInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->deleteServiceInstance: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->deleteServiceInstance(version => $version, serviceInstanceId => $serviceInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->deleteServiceInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Delete provided Service Instance
    api_instance.delete_service_instance(version, serviceInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->deleteServiceInstance: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String vfmoduleInstanceId = vfmoduleInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deleteVfModuleInstance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deleteVfModuleInstance");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String vfmoduleInstanceId = vfmoduleInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deleteVfModuleInstance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deleteVfModuleInstance");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *vnfInstanceId = vnfInstanceId_example; // 
String *vfmoduleInstanceId = vfmoduleInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Delete provided VfModule instance
[apiInstance deleteVfModuleInstanceWith:version
    serviceInstanceId:serviceInstanceId
    vnfInstanceId:vnfInstanceId
    vfmoduleInstanceId:vfmoduleInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var vnfInstanceId = vnfInstanceId_example; // {String} 

var vfmoduleInstanceId = vfmoduleInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class deleteVfModuleInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var vnfInstanceId = vnfInstanceId_example;  // String | 
            var vfmoduleInstanceId = vfmoduleInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Delete provided VfModule instance
                apiInstance.deleteVfModuleInstance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.deleteVfModuleInstance: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$vnfInstanceId = vnfInstanceId_example; // String | 
$vfmoduleInstanceId = vfmoduleInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->deleteVfModuleInstance($version, $serviceInstanceId, $vnfInstanceId, $vfmoduleInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->deleteVfModuleInstance: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $vnfInstanceId = vnfInstanceId_example; # String | 
my $vfmoduleInstanceId = vfmoduleInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->deleteVfModuleInstance(version => $version, serviceInstanceId => $serviceInstanceId, vnfInstanceId => $vnfInstanceId, vfmoduleInstanceId => $vfmoduleInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->deleteVfModuleInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
vnfInstanceId = vnfInstanceId_example # String | 
vfmoduleInstanceId = vfmoduleInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Delete provided VfModule instance
    api_instance.delete_vf_module_instance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->deleteVfModuleInstance: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deleteVnfInstance(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deleteVnfInstance");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deleteVnfInstance(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deleteVnfInstance");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *vnfInstanceId = vnfInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Delete provided VNF instance
[apiInstance deleteVnfInstanceWith:version
    serviceInstanceId:serviceInstanceId
    vnfInstanceId:vnfInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var vnfInstanceId = vnfInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class deleteVnfInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var vnfInstanceId = vnfInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Delete provided VNF instance
                apiInstance.deleteVnfInstance(version, serviceInstanceId, vnfInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.deleteVnfInstance: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$vnfInstanceId = vnfInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->deleteVnfInstance($version, $serviceInstanceId, $vnfInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->deleteVnfInstance: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $vnfInstanceId = vnfInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->deleteVnfInstance(version => $version, serviceInstanceId => $serviceInstanceId, vnfInstanceId => $vnfInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->deleteVnfInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
vnfInstanceId = vnfInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Delete provided VNF instance
    api_instance.delete_vnf_instance(version, serviceInstanceId, vnfInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->deleteVnfInstance: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String volumeGroupInstanceId = volumeGroupInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deleteVolumeGroupInstance(version, serviceInstanceId, vnfInstanceId, volumeGroupInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deleteVolumeGroupInstance");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String volumeGroupInstanceId = volumeGroupInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.deleteVolumeGroupInstance(version, serviceInstanceId, vnfInstanceId, volumeGroupInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#deleteVolumeGroupInstance");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *vnfInstanceId = vnfInstanceId_example; // 
String *volumeGroupInstanceId = volumeGroupInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Delete provided VolumeGroup instance
[apiInstance deleteVolumeGroupInstanceWith:version
    serviceInstanceId:serviceInstanceId
    vnfInstanceId:vnfInstanceId
    volumeGroupInstanceId:volumeGroupInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var vnfInstanceId = vnfInstanceId_example; // {String} 

var volumeGroupInstanceId = volumeGroupInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class deleteVolumeGroupInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var vnfInstanceId = vnfInstanceId_example;  // String | 
            var volumeGroupInstanceId = volumeGroupInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Delete provided VolumeGroup instance
                apiInstance.deleteVolumeGroupInstance(version, serviceInstanceId, vnfInstanceId, volumeGroupInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.deleteVolumeGroupInstance: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$vnfInstanceId = vnfInstanceId_example; // String | 
$volumeGroupInstanceId = volumeGroupInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->deleteVolumeGroupInstance($version, $serviceInstanceId, $vnfInstanceId, $volumeGroupInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->deleteVolumeGroupInstance: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $vnfInstanceId = vnfInstanceId_example; # String | 
my $volumeGroupInstanceId = volumeGroupInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->deleteVolumeGroupInstance(version => $version, serviceInstanceId => $serviceInstanceId, vnfInstanceId => $vnfInstanceId, volumeGroupInstanceId => $volumeGroupInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->deleteVolumeGroupInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
vnfInstanceId = vnfInstanceId_example # String | 
volumeGroupInstanceId = volumeGroupInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Delete provided VolumeGroup instance
    api_instance.delete_volume_group_instance(version, serviceInstanceId, vnfInstanceId, volumeGroupInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->deleteVolumeGroupInstance: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String configurationInstanceId = configurationInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.disablePort(version, serviceInstanceId, configurationInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#disablePort");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String configurationInstanceId = configurationInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.disablePort(version, serviceInstanceId, configurationInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#disablePort");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *configurationInstanceId = configurationInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Disable Port Mirroring
[apiInstance disablePortWith:version
    serviceInstanceId:serviceInstanceId
    configurationInstanceId:configurationInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var configurationInstanceId = configurationInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class disablePortExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var configurationInstanceId = configurationInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Disable Port Mirroring
                apiInstance.disablePort(version, serviceInstanceId, configurationInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.disablePort: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$configurationInstanceId = configurationInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->disablePort($version, $serviceInstanceId, $configurationInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->disablePort: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $configurationInstanceId = configurationInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->disablePort(version => $version, serviceInstanceId => $serviceInstanceId, configurationInstanceId => $configurationInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->disablePort: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
configurationInstanceId = configurationInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Disable Port Mirroring
    api_instance.disable_port(version, serviceInstanceId, configurationInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->disablePort: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String configurationInstanceId = configurationInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.enablePort(version, serviceInstanceId, configurationInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#enablePort");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String configurationInstanceId = configurationInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.enablePort(version, serviceInstanceId, configurationInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#enablePort");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *configurationInstanceId = configurationInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Enable Port Mirroring
[apiInstance enablePortWith:version
    serviceInstanceId:serviceInstanceId
    configurationInstanceId:configurationInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var configurationInstanceId = configurationInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class enablePortExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var configurationInstanceId = configurationInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Enable Port Mirroring
                apiInstance.enablePort(version, serviceInstanceId, configurationInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.enablePort: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$configurationInstanceId = configurationInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->enablePort($version, $serviceInstanceId, $configurationInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->enablePort: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $configurationInstanceId = configurationInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->enablePort(version => $version, serviceInstanceId => $serviceInstanceId, configurationInstanceId => $configurationInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->enablePort: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
configurationInstanceId = configurationInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Enable Port Mirroring
    api_instance.enable_port(version, serviceInstanceId, configurationInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->enablePort: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.inPlaceSoftwareUpdate(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#inPlaceSoftwareUpdate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.inPlaceSoftwareUpdate(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#inPlaceSoftwareUpdate");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *vnfInstanceId = vnfInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Perform VNF software update
[apiInstance inPlaceSoftwareUpdateWith:version
    serviceInstanceId:serviceInstanceId
    vnfInstanceId:vnfInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var vnfInstanceId = vnfInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class inPlaceSoftwareUpdateExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var vnfInstanceId = vnfInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Perform VNF software update
                apiInstance.inPlaceSoftwareUpdate(version, serviceInstanceId, vnfInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.inPlaceSoftwareUpdate: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$vnfInstanceId = vnfInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->inPlaceSoftwareUpdate($version, $serviceInstanceId, $vnfInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->inPlaceSoftwareUpdate: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $vnfInstanceId = vnfInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->inPlaceSoftwareUpdate(version => $version, serviceInstanceId => $serviceInstanceId, vnfInstanceId => $vnfInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->inPlaceSoftwareUpdate: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
vnfInstanceId = vnfInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Perform VNF software update
    api_instance.in_place_software_update(version, serviceInstanceId, vnfInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->inPlaceSoftwareUpdate: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.removeRelationships(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#removeRelationships");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.removeRelationships(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#removeRelationships");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Remove Relationships from Service Instance
[apiInstance removeRelationshipsWith:version
    serviceInstanceId:serviceInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class removeRelationshipsExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Remove Relationships from Service Instance
                apiInstance.removeRelationships(version, serviceInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.removeRelationships: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->removeRelationships($version, $serviceInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->removeRelationships: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->removeRelationships(version => $version, serviceInstanceId => $serviceInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->removeRelationships: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Remove Relationships from Service Instance
    api_instance.remove_relationships(version, serviceInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->removeRelationships: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String vfmoduleInstanceId = vfmoduleInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.replaceVfModuleInstance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#replaceVfModuleInstance");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String vfmoduleInstanceId = vfmoduleInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.replaceVfModuleInstance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#replaceVfModuleInstance");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *vnfInstanceId = vnfInstanceId_example; // 
String *vfmoduleInstanceId = vfmoduleInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Create VfModule on a specified version, serviceInstance and vnfInstance
[apiInstance replaceVfModuleInstanceWith:version
    serviceInstanceId:serviceInstanceId
    vnfInstanceId:vnfInstanceId
    vfmoduleInstanceId:vfmoduleInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var vnfInstanceId = vnfInstanceId_example; // {String} 

var vfmoduleInstanceId = vfmoduleInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class replaceVfModuleInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var vnfInstanceId = vnfInstanceId_example;  // String | 
            var vfmoduleInstanceId = vfmoduleInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Create VfModule on a specified version, serviceInstance and vnfInstance
                apiInstance.replaceVfModuleInstance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.replaceVfModuleInstance: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$vnfInstanceId = vnfInstanceId_example; // String | 
$vfmoduleInstanceId = vfmoduleInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->replaceVfModuleInstance($version, $serviceInstanceId, $vnfInstanceId, $vfmoduleInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->replaceVfModuleInstance: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $vnfInstanceId = vnfInstanceId_example; # String | 
my $vfmoduleInstanceId = vfmoduleInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->replaceVfModuleInstance(version => $version, serviceInstanceId => $serviceInstanceId, vnfInstanceId => $vnfInstanceId, vfmoduleInstanceId => $vfmoduleInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->replaceVfModuleInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
vnfInstanceId = vnfInstanceId_example # String | 
vfmoduleInstanceId = vfmoduleInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Create VfModule on a specified version, serviceInstance and vnfInstance
    api_instance.replace_vf_module_instance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->replaceVfModuleInstance: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.replaceVnfInstance(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#replaceVnfInstance");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.replaceVnfInstance(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#replaceVnfInstance");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *vnfInstanceId = vnfInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Replace provided VNF instance
[apiInstance replaceVnfInstanceWith:version
    serviceInstanceId:serviceInstanceId
    vnfInstanceId:vnfInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var vnfInstanceId = vnfInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class replaceVnfInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var vnfInstanceId = vnfInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Replace provided VNF instance
                apiInstance.replaceVnfInstance(version, serviceInstanceId, vnfInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.replaceVnfInstance: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$vnfInstanceId = vnfInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->replaceVnfInstance($version, $serviceInstanceId, $vnfInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->replaceVnfInstance: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $vnfInstanceId = vnfInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->replaceVnfInstance(version => $version, serviceInstanceId => $serviceInstanceId, vnfInstanceId => $vnfInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->replaceVnfInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
vnfInstanceId = vnfInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Replace provided VNF instance
    api_instance.replace_vnf_instance(version, serviceInstanceId, vnfInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->replaceVnfInstance: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.scaleOutVfModule(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#scaleOutVfModule");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.scaleOutVfModule(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#scaleOutVfModule");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *vnfInstanceId = vnfInstanceId_example; // 
String *body = body_example; //  (optional)

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

// VF Auto Scale Out
[apiInstance scaleOutVfModuleWith:version
    serviceInstanceId:serviceInstanceId
    vnfInstanceId:vnfInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var vnfInstanceId = vnfInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class scaleOutVfModuleExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var vnfInstanceId = vnfInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // VF Auto Scale Out
                apiInstance.scaleOutVfModule(version, serviceInstanceId, vnfInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.scaleOutVfModule: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$vnfInstanceId = vnfInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->scaleOutVfModule($version, $serviceInstanceId, $vnfInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->scaleOutVfModule: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $vnfInstanceId = vnfInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->scaleOutVfModule(version => $version, serviceInstanceId => $serviceInstanceId, vnfInstanceId => $vnfInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->scaleOutVfModule: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
vnfInstanceId = vnfInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # VF Auto Scale Out
    api_instance.scale_out_vf_module(version, serviceInstanceId, vnfInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->scaleOutVfModule: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.unassignServiceInstance(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#unassignServiceInstance");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.unassignServiceInstance(version, serviceInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#unassignServiceInstance");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Unassign Service Instance
[apiInstance unassignServiceInstanceWith:version
    serviceInstanceId:serviceInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class unassignServiceInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Unassign Service Instance
                apiInstance.unassignServiceInstance(version, serviceInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.unassignServiceInstance: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->unassignServiceInstance($version, $serviceInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->unassignServiceInstance: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->unassignServiceInstance(version => $version, serviceInstanceId => $serviceInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->unassignServiceInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Unassign Service Instance
    api_instance.unassign_service_instance(version, serviceInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->unassignServiceInstance: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String networkInstanceId = networkInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.updateNetworkInstance(version, serviceInstanceId, networkInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#updateNetworkInstance");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String networkInstanceId = networkInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.updateNetworkInstance(version, serviceInstanceId, networkInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#updateNetworkInstance");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *networkInstanceId = networkInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Update VolumeGroup on a specified version, serviceInstance, networkInstance
[apiInstance updateNetworkInstanceWith:version
    serviceInstanceId:serviceInstanceId
    networkInstanceId:networkInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var networkInstanceId = networkInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class updateNetworkInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var networkInstanceId = networkInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Update VolumeGroup on a specified version, serviceInstance, networkInstance
                apiInstance.updateNetworkInstance(version, serviceInstanceId, networkInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.updateNetworkInstance: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$networkInstanceId = networkInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->updateNetworkInstance($version, $serviceInstanceId, $networkInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->updateNetworkInstance: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $networkInstanceId = networkInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->updateNetworkInstance(version => $version, serviceInstanceId => $serviceInstanceId, networkInstanceId => $networkInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->updateNetworkInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
networkInstanceId = networkInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Update VolumeGroup on a specified version, serviceInstance, networkInstance
    api_instance.update_network_instance(version, serviceInstanceId, networkInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->updateNetworkInstance: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String vfmoduleInstanceId = vfmoduleInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.updateVfModuleInstance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#updateVfModuleInstance");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String vfmoduleInstanceId = vfmoduleInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.updateVfModuleInstance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#updateVfModuleInstance");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *vnfInstanceId = vnfInstanceId_example; // 
String *vfmoduleInstanceId = vfmoduleInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Update VfModule on a specified version, serviceInstance, vnfInstance and vfModule
[apiInstance updateVfModuleInstanceWith:version
    serviceInstanceId:serviceInstanceId
    vnfInstanceId:vnfInstanceId
    vfmoduleInstanceId:vfmoduleInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var vnfInstanceId = vnfInstanceId_example; // {String} 

var vfmoduleInstanceId = vfmoduleInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class updateVfModuleInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var vnfInstanceId = vnfInstanceId_example;  // String | 
            var vfmoduleInstanceId = vfmoduleInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Update VfModule on a specified version, serviceInstance, vnfInstance and vfModule
                apiInstance.updateVfModuleInstance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.updateVfModuleInstance: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$vnfInstanceId = vnfInstanceId_example; // String | 
$vfmoduleInstanceId = vfmoduleInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->updateVfModuleInstance($version, $serviceInstanceId, $vnfInstanceId, $vfmoduleInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->updateVfModuleInstance: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $vnfInstanceId = vnfInstanceId_example; # String | 
my $vfmoduleInstanceId = vfmoduleInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->updateVfModuleInstance(version => $version, serviceInstanceId => $serviceInstanceId, vnfInstanceId => $vnfInstanceId, vfmoduleInstanceId => $vfmoduleInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->updateVfModuleInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
vnfInstanceId = vnfInstanceId_example # String | 
vfmoduleInstanceId = vfmoduleInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Update VfModule on a specified version, serviceInstance, vnfInstance and vfModule
    api_instance.update_vf_module_instance(version, serviceInstanceId, vnfInstanceId, vfmoduleInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->updateVfModuleInstance: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.updateVnfInstance(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#updateVnfInstance");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.updateVnfInstance(version, serviceInstanceId, vnfInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#updateVnfInstance");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *vnfInstanceId = vnfInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Update VNF on a specified version, serviceInstance and vnfInstance
[apiInstance updateVnfInstanceWith:version
    serviceInstanceId:serviceInstanceId
    vnfInstanceId:vnfInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var vnfInstanceId = vnfInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class updateVnfInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var vnfInstanceId = vnfInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Update VNF on a specified version, serviceInstance and vnfInstance
                apiInstance.updateVnfInstance(version, serviceInstanceId, vnfInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.updateVnfInstance: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$vnfInstanceId = vnfInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->updateVnfInstance($version, $serviceInstanceId, $vnfInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->updateVnfInstance: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $vnfInstanceId = vnfInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->updateVnfInstance(version => $version, serviceInstanceId => $serviceInstanceId, vnfInstanceId => $vnfInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->updateVnfInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
vnfInstanceId = vnfInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Update VNF on a specified version, serviceInstance and vnfInstance
    api_instance.update_vnf_instance(version, serviceInstanceId, vnfInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->updateVnfInstance: %s\n" % e)

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

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

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String volumeGroupInstanceId = volumeGroupInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.updateVolumeGroupInstance(version, serviceInstanceId, vnfInstanceId, volumeGroupInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#updateVolumeGroupInstance");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfraserviceInstantiationApi;

public class OnapsoinfraserviceInstantiationApiExample {

    public static void main(String[] args) {
        OnapsoinfraserviceInstantiationApi apiInstance = new OnapsoinfraserviceInstantiationApi();
        String version = version_example; // String | 
        String serviceInstanceId = serviceInstanceId_example; // String | 
        String vnfInstanceId = vnfInstanceId_example; // String | 
        String volumeGroupInstanceId = volumeGroupInstanceId_example; // String | 
        String body = body_example; // String | 
        try {
            apiInstance.updateVolumeGroupInstance(version, serviceInstanceId, vnfInstanceId, volumeGroupInstanceId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfraserviceInstantiationApi#updateVolumeGroupInstance");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *serviceInstanceId = serviceInstanceId_example; // 
String *vnfInstanceId = vnfInstanceId_example; // 
String *volumeGroupInstanceId = volumeGroupInstanceId_example; // 
String *body = body_example; //  (optional)

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

// Update VolumeGroup on a specified version, serviceInstance, vnfInstance and volumeGroup
[apiInstance updateVolumeGroupInstanceWith:version
    serviceInstanceId:serviceInstanceId
    vnfInstanceId:vnfInstanceId
    volumeGroupInstanceId:volumeGroupInstanceId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfraserviceInstantiationApi()

var version = version_example; // {String} 

var serviceInstanceId = serviceInstanceId_example; // {String} 

var vnfInstanceId = vnfInstanceId_example; // {String} 

var volumeGroupInstanceId = volumeGroupInstanceId_example; // {String} 

var opts = { 
  'body': body_example // {String} 
};

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

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

namespace Example
{
    public class updateVolumeGroupInstanceExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfraserviceInstantiationApi();
            var version = version_example;  // String | 
            var serviceInstanceId = serviceInstanceId_example;  // String | 
            var vnfInstanceId = vnfInstanceId_example;  // String | 
            var volumeGroupInstanceId = volumeGroupInstanceId_example;  // String | 
            var body = body_example;  // String |  (optional) 

            try
            {
                // Update VolumeGroup on a specified version, serviceInstance, vnfInstance and volumeGroup
                apiInstance.updateVolumeGroupInstance(version, serviceInstanceId, vnfInstanceId, volumeGroupInstanceId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfraserviceInstantiationApi.updateVolumeGroupInstance: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfraserviceInstantiationApi();
$version = version_example; // String | 
$serviceInstanceId = serviceInstanceId_example; // String | 
$vnfInstanceId = vnfInstanceId_example; // String | 
$volumeGroupInstanceId = volumeGroupInstanceId_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->updateVolumeGroupInstance($version, $serviceInstanceId, $vnfInstanceId, $volumeGroupInstanceId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfraserviceInstantiationApi->updateVolumeGroupInstance: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfraserviceInstantiationApi->new();
my $version = version_example; # String | 
my $serviceInstanceId = serviceInstanceId_example; # String | 
my $vnfInstanceId = vnfInstanceId_example; # String | 
my $volumeGroupInstanceId = volumeGroupInstanceId_example; # String | 
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->updateVolumeGroupInstance(version => $version, serviceInstanceId => $serviceInstanceId, vnfInstanceId => $vnfInstanceId, volumeGroupInstanceId => $volumeGroupInstanceId, body => $body);
};
if ($@) {
    warn "Exception when calling OnapsoinfraserviceInstantiationApi->updateVolumeGroupInstance: $@\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.OnapsoinfraserviceInstantiationApi()
version = version_example # String | 
serviceInstanceId = serviceInstanceId_example # String | 
vnfInstanceId = vnfInstanceId_example # String | 
volumeGroupInstanceId = volumeGroupInstanceId_example # String | 
body = body_example # String |  (optional)

try: 
    # Update VolumeGroup on a specified version, serviceInstance, vnfInstance and volumeGroup
    api_instance.update_volume_group_instance(version, serviceInstanceId, vnfInstanceId, volumeGroupInstanceId, body=body)
except ApiException as e:
    print("Exception when calling OnapsoinfraserviceInstantiationApi->updateVolumeGroupInstance: %s\n" % e)

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

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

public class OnapsoinfratasksApiExample {

    public static void main(String[] args) {
        
        OnapsoinfratasksApi apiInstance = new OnapsoinfratasksApi();
        String version = version_example; // String | 
        String taskId = taskId_example; // String | 
        String originalRequestId = originalRequestId_example; // String | 
        String subscriptionServiceType = subscriptionServiceType_example; // String | 
        String nfRole = nfRole_example; // String | 
        String buildingBlockName = buildingBlockName_example; // String | 
        String originalRequestDate = originalRequestDate_example; // String | 
        String originalRequestorId = originalRequestorId_example; // String | 
        try {
            apiInstance.queryFilters(version, taskId, originalRequestId, subscriptionServiceType, nfRole, buildingBlockName, originalRequestDate, originalRequestorId);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfratasksApi#queryFilters");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OnapsoinfratasksApi;

public class OnapsoinfratasksApiExample {

    public static void main(String[] args) {
        OnapsoinfratasksApi apiInstance = new OnapsoinfratasksApi();
        String version = version_example; // String | 
        String taskId = taskId_example; // String | 
        String originalRequestId = originalRequestId_example; // String | 
        String subscriptionServiceType = subscriptionServiceType_example; // String | 
        String nfRole = nfRole_example; // String | 
        String buildingBlockName = buildingBlockName_example; // String | 
        String originalRequestDate = originalRequestDate_example; // String | 
        String originalRequestorId = originalRequestorId_example; // String | 
        try {
            apiInstance.queryFilters(version, taskId, originalRequestId, subscriptionServiceType, nfRole, buildingBlockName, originalRequestDate, originalRequestorId);
        } catch (ApiException e) {
            System.err.println("Exception when calling OnapsoinfratasksApi#queryFilters");
            e.printStackTrace();
        }
    }
}

String *version = version_example; // 
String *taskId = taskId_example; //  (optional)
String *originalRequestId = originalRequestId_example; //  (optional)
String *subscriptionServiceType = subscriptionServiceType_example; //  (optional)
String *nfRole = nfRole_example; //  (optional)
String *buildingBlockName = buildingBlockName_example; //  (optional)
String *originalRequestDate = originalRequestDate_example; //  (optional)
String *originalRequestorId = originalRequestorId_example; //  (optional)

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

// Finds Manual Tasks
[apiInstance queryFiltersWith:version
    taskId:taskId
    originalRequestId:originalRequestId
    subscriptionServiceType:subscriptionServiceType
    nfRole:nfRole
    buildingBlockName:buildingBlockName
    originalRequestDate:originalRequestDate
    originalRequestorId:originalRequestorId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SoGuilinApIs = require('so_guilin_ap_is');

var api = new SoGuilinApIs.OnapsoinfratasksApi()

var version = version_example; // {String} 

var opts = { 
  'taskId': taskId_example, // {String} 
  'originalRequestId': originalRequestId_example, // {String} 
  'subscriptionServiceType': subscriptionServiceType_example, // {String} 
  'nfRole': nfRole_example, // {String} 
  'buildingBlockName': buildingBlockName_example, // {String} 
  'originalRequestDate': originalRequestDate_example, // {String} 
  'originalRequestorId': originalRequestorId_example // {String} 
};

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

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

namespace Example
{
    public class queryFiltersExample
    {
        public void main()
        {
            
            var apiInstance = new OnapsoinfratasksApi();
            var version = version_example;  // String | 
            var taskId = taskId_example;  // String |  (optional) 
            var originalRequestId = originalRequestId_example;  // String |  (optional) 
            var subscriptionServiceType = subscriptionServiceType_example;  // String |  (optional) 
            var nfRole = nfRole_example;  // String |  (optional) 
            var buildingBlockName = buildingBlockName_example;  // String |  (optional) 
            var originalRequestDate = originalRequestDate_example;  // String |  (optional) 
            var originalRequestorId = originalRequestorId_example;  // String |  (optional) 

            try
            {
                // Finds Manual Tasks
                apiInstance.queryFilters(version, taskId, originalRequestId, subscriptionServiceType, nfRole, buildingBlockName, originalRequestDate, originalRequestorId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OnapsoinfratasksApi.queryFilters: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\OnapsoinfratasksApi();
$version = version_example; // String | 
$taskId = taskId_example; // String | 
$originalRequestId = originalRequestId_example; // String | 
$subscriptionServiceType = subscriptionServiceType_example; // String | 
$nfRole = nfRole_example; // String | 
$buildingBlockName = buildingBlockName_example; // String | 
$originalRequestDate = originalRequestDate_example; // String | 
$originalRequestorId = originalRequestorId_example; // String | 

try {
    $api_instance->queryFilters($version, $taskId, $originalRequestId, $subscriptionServiceType, $nfRole, $buildingBlockName, $originalRequestDate, $originalRequestorId);
} catch (Exception $e) {
    echo 'Exception when calling OnapsoinfratasksApi->queryFilters: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::OnapsoinfratasksApi->new();
my $version = version_example; # String | 
my $taskId = taskId_example; # String | 
my $originalRequestId = originalRequestId_example; # String | 
my $subscriptionServiceType = subscriptionServiceType_example; # String | 
my $nfRole = nfRole_example; # String | 
my $buildingBlockName = buildingBlockName_example; # String | 
my $originalRequestDate = originalRequestDate_example; # String | 
my $originalRequestorId = originalRequestorId_example; # String | 

eval { 
    $api_instance->queryFilters(version => $version, taskId => $taskId, originalRequestId => $originalRequestId, subscriptionServiceType => $subscriptionServiceType, nfRole => $nfRole, buildingBlockName => $buildingBlockName, originalRequestDate => $originalRequestDate, originalRequestorId => $originalRequestorId);
};
if ($@) {
    warn "Exception when calling OnapsoinfratasksApi->queryFilters: $@\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.OnapsoinfratasksApi()
version = version_example # String | 
taskId = taskId_example # String |  (optional)
originalRequestId = originalRequestId_example # String |  (optional)
subscriptionServiceType = subscriptionServiceType_example # String |  (optional)
nfRole = nfRole_example # String |  (optional)
buildingBlockName = buildingBlockName_example # String |  (optional)
originalRequestDate = originalRequestDate_example # String |  (optional)
originalRequestorId = originalRequestorId_example # String |  (optional)

try: 
    # Finds Manual Tasks
    api_instance.query_filters(version, taskId=taskId, originalRequestId=originalRequestId, subscriptionServiceType=subscriptionServiceType, nfRole=nfRole, buildingBlockName=buildingBlockName, originalRequestDate=originalRequestDate, originalRequestorId=originalRequestorId)
except ApiException as e:
    print("Exception when calling OnapsoinfratasksApi->queryFilters: %s\n" % e)