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

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

public class CasappApiExample {

    public static void main(String[] args) {
        
        CasappApi apiInstance = new CasappApi();
        CasApp body = ; // CasApp | CAS Application to add
        try {
            apiInstance.addcasapp(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CasappApi#addcasapp");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CasappApi;

public class CasappApiExample {

    public static void main(String[] args) {
        CasappApi apiInstance = new CasappApi();
        CasApp body = ; // CasApp | CAS Application to add
        try {
            apiInstance.addcasapp(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CasappApi#addcasapp");
            e.printStackTrace();
        }
    }
}

CasApp *body = ; // CAS Application to add

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

// Create a new CAS Application
[apiInstance addcasappWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.CasappApi()
var body = ; // {{CasApp}} CAS Application to add

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

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

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

            var apiInstance = new CasappApi();
            var body = new CasApp(); // CasApp | CAS Application to add

            try
            {
                // Create a new CAS Application
                apiInstance.addcasapp(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CasappApi.addcasapp: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCasappApi();
$body = ; // CasApp | CAS Application to add

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

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

my $api_instance = WWW::SwaggerClient::CasappApi->new();
my $body = WWW::SwaggerClient::Object::CasApp->new(); # CasApp | CAS Application to add

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

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

# create an instance of the API class
api_instance = swagger_client.CasappApi()
body =  # CasApp | CAS Application to add

try: 
    # Create a new CAS Application
    api_instance.addcasapp(body)
except ApiException as e:
    print("Exception when calling CasappApi->addcasapp: %s\n" % e)

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

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

public class CasappApiExample {

    public static void main(String[] args) {
        
        CasappApi apiInstance = new CasappApi();
        confKey confKey = ; // confKey | Configuration key of CAS Application to delete
        try {
            apiInstance.deleteCasApp(confKey);
        } catch (ApiException e) {
            System.err.println("Exception when calling CasappApi#deleteCasApp");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CasappApi;

public class CasappApiExample {

    public static void main(String[] args) {
        CasappApi apiInstance = new CasappApi();
        confKey confKey = ; // confKey | Configuration key of CAS Application to delete
        try {
            apiInstance.deleteCasApp(confKey);
        } catch (ApiException e) {
            System.err.println("Exception when calling CasappApi#deleteCasApp");
            e.printStackTrace();
        }
    }
}

confKey *confKey = ; // Configuration key of CAS Application to delete

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

// Deletes a CAS Application
[apiInstance deleteCasAppWith:confKey
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.CasappApi()
var confKey = ; // {{confKey}} Configuration key of CAS Application to delete

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

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

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

            var apiInstance = new CasappApi();
            var confKey = new confKey(); // confKey | Configuration key of CAS Application to delete

            try
            {
                // Deletes a CAS Application
                apiInstance.deleteCasApp(confKey);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CasappApi.deleteCasApp: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCasappApi();
$confKey = ; // confKey | Configuration key of CAS Application to delete

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

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

my $api_instance = WWW::SwaggerClient::CasappApi->new();
my $confKey = ; # confKey | Configuration key of CAS Application to delete

eval { 
    $api_instance->deleteCasApp(confKey => $confKey);
};
if ($@) {
    warn "Exception when calling CasappApi->deleteCasApp: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.CasappApi()
confKey =  # confKey | Configuration key of CAS Application to delete

try: 
    # Deletes a CAS Application
    api_instance.delete_cas_app(confKey)
except ApiException as e:
    print("Exception when calling CasappApi->deleteCasApp: %s\n" % e)

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

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

public class CasappApiExample {

    public static void main(String[] args) {
        
        CasappApi apiInstance = new CasappApi();
        String pattern = pattern_example; // String | Search pattern
        try {
            array[CasApp] result = apiInstance.findCasAppByConfKey(pattern);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CasappApi#findCasAppByConfKey");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CasappApi;

public class CasappApiExample {

    public static void main(String[] args) {
        CasappApi apiInstance = new CasappApi();
        String pattern = pattern_example; // String | Search pattern
        try {
            array[CasApp] result = apiInstance.findCasAppByConfKey(pattern);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CasappApi#findCasAppByConfKey");
            e.printStackTrace();
        }
    }
}

String *pattern = pattern_example; // Search pattern

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

// Finds CAS applications by configuration key
[apiInstance findCasAppByConfKeyWith:pattern
              completionHandler: ^(array[CasApp] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.CasappApi()
var pattern = pattern_example; // {{String}} Search pattern

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

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

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

            var apiInstance = new CasappApi();
            var pattern = pattern_example;  // String | Search pattern

            try
            {
                // Finds CAS applications by configuration key
                array[CasApp] result = apiInstance.findCasAppByConfKey(pattern);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CasappApi.findCasAppByConfKey: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCasappApi();
$pattern = pattern_example; // String | Search pattern

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

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

my $api_instance = WWW::SwaggerClient::CasappApi->new();
my $pattern = pattern_example; # String | Search pattern

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

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

# create an instance of the API class
api_instance = swagger_client.CasappApi()
pattern = pattern_example # String | Search pattern

try: 
    # Finds CAS applications by configuration key
    api_response = api_instance.find_cas_app_by_conf_key(pattern)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CasappApi->findCasAppByConfKey: %s\n" % e)

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

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

public class CasappApiExample {

    public static void main(String[] args) {
        
        CasappApi apiInstance = new CasappApi();
        String serviceUrl = serviceUrl_example; // String | Service URL to search
        try {
            CasApp result = apiInstance.findCasAppByServiceUrl(serviceUrl);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CasappApi#findCasAppByServiceUrl");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CasappApi;

public class CasappApiExample {

    public static void main(String[] args) {
        CasappApi apiInstance = new CasappApi();
        String serviceUrl = serviceUrl_example; // String | Service URL to search
        try {
            CasApp result = apiInstance.findCasAppByServiceUrl(serviceUrl);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CasappApi#findCasAppByServiceUrl");
            e.printStackTrace();
        }
    }
}

String *serviceUrl = serviceUrl_example; // Service URL to search

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

// Get CAS Application by Service URL
[apiInstance findCasAppByServiceUrlWith:serviceUrl
              completionHandler: ^(CasApp output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.CasappApi()
var serviceUrl = serviceUrl_example; // {{String}} Service URL to search

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

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

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

            var apiInstance = new CasappApi();
            var serviceUrl = serviceUrl_example;  // String | Service URL to search

            try
            {
                // Get CAS Application by Service URL
                CasApp result = apiInstance.findCasAppByServiceUrl(serviceUrl);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CasappApi.findCasAppByServiceUrl: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCasappApi();
$serviceUrl = serviceUrl_example; // String | Service URL to search

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

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

my $api_instance = WWW::SwaggerClient::CasappApi->new();
my $serviceUrl = serviceUrl_example; # String | Service URL to search

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

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

# create an instance of the API class
api_instance = swagger_client.CasappApi()
serviceUrl = serviceUrl_example # String | Service URL to search

try: 
    # Get CAS Application by Service URL
    api_response = api_instance.find_cas_app_by_service_url(serviceUrl)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CasappApi->findCasAppByServiceUrl: %s\n" % e)

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

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

public class CasappApiExample {

    public static void main(String[] args) {
        
        CasappApi apiInstance = new CasappApi();
        confKey confKey = ; // confKey | Configuration key of CAS Application
        try {
            CasApp result = apiInstance.getCasAppByConfKey(confKey);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CasappApi#getCasAppByConfKey");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CasappApi;

public class CasappApiExample {

    public static void main(String[] args) {
        CasappApi apiInstance = new CasappApi();
        confKey confKey = ; // confKey | Configuration key of CAS Application
        try {
            CasApp result = apiInstance.getCasAppByConfKey(confKey);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CasappApi#getCasAppByConfKey");
            e.printStackTrace();
        }
    }
}

confKey *confKey = ; // Configuration key of CAS Application

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

// Get CAS Application by configuration key
[apiInstance getCasAppByConfKeyWith:confKey
              completionHandler: ^(CasApp output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.CasappApi()
var confKey = ; // {{confKey}} Configuration key of CAS Application

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

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

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

            var apiInstance = new CasappApi();
            var confKey = new confKey(); // confKey | Configuration key of CAS Application

            try
            {
                // Get CAS Application by configuration key
                CasApp result = apiInstance.getCasAppByConfKey(confKey);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CasappApi.getCasAppByConfKey: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCasappApi();
$confKey = ; // confKey | Configuration key of CAS Application

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

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

my $api_instance = WWW::SwaggerClient::CasappApi->new();
my $confKey = ; # confKey | Configuration key of CAS Application

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

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

# create an instance of the API class
api_instance = swagger_client.CasappApi()
confKey =  # confKey | Configuration key of CAS Application

try: 
    # Get CAS Application by configuration key
    api_response = api_instance.get_cas_app_by_conf_key(confKey)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CasappApi->getCasAppByConfKey: %s\n" % e)

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

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

public class CasappApiExample {

    public static void main(String[] args) {
        
        CasappApi apiInstance = new CasappApi();
        confKey confKey = ; // confKey | Configuration key of CAS Application that needs to be replaced
        CasAppReplace body = ; // CasAppReplace | 
        try {
            apiInstance.replaceCasApp(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CasappApi#replaceCasApp");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CasappApi;

public class CasappApiExample {

    public static void main(String[] args) {
        CasappApi apiInstance = new CasappApi();
        confKey confKey = ; // confKey | Configuration key of CAS Application that needs to be replaced
        CasAppReplace body = ; // CasAppReplace | 
        try {
            apiInstance.replaceCasApp(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CasappApi#replaceCasApp");
            e.printStackTrace();
        }
    }
}

confKey *confKey = ; // Configuration key of CAS Application that needs to be replaced
CasAppReplace *body = ; //  (optional)

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

// Replaces a CAS Application
[apiInstance replaceCasAppWith:confKey
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.CasappApi()
var confKey = ; // {{confKey}} Configuration key of CAS Application that needs to be replaced
var opts = { 
  'body':  // {{CasAppReplace}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.replaceCasApp(confKey, opts, callback);

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

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

            var apiInstance = new CasappApi();
            var confKey = new confKey(); // confKey | Configuration key of CAS Application that needs to be replaced
            var body = new CasAppReplace(); // CasAppReplace |  (optional) 

            try
            {
                // Replaces a CAS Application
                apiInstance.replaceCasApp(confKey, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CasappApi.replaceCasApp: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCasappApi();
$confKey = ; // confKey | Configuration key of CAS Application that needs to be replaced
$body = ; // CasAppReplace | 

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

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

my $api_instance = WWW::SwaggerClient::CasappApi->new();
my $confKey = ; # confKey | Configuration key of CAS Application that needs to be replaced
my $body = WWW::SwaggerClient::Object::CasAppReplace->new(); # CasAppReplace | 

eval { 
    $api_instance->replaceCasApp(confKey => $confKey, body => $body);
};
if ($@) {
    warn "Exception when calling CasappApi->replaceCasApp: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.CasappApi()
confKey =  # confKey | Configuration key of CAS Application that needs to be replaced
body =  # CasAppReplace |  (optional)

try: 
    # Replaces a CAS Application
    api_instance.replace_cas_app(confKey, body=body)
except ApiException as e:
    print("Exception when calling CasappApi->replaceCasApp: %s\n" % e)

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

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

public class CasappApiExample {

    public static void main(String[] args) {
        
        CasappApi apiInstance = new CasappApi();
        confKey confKey = ; // confKey | Configuration key of CAS Application that needs to be updated
        CasAppUpdate body = ; // CasAppUpdate | 
        try {
            apiInstance.updateCasApp(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CasappApi#updateCasApp");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CasappApi;

public class CasappApiExample {

    public static void main(String[] args) {
        CasappApi apiInstance = new CasappApi();
        confKey confKey = ; // confKey | Configuration key of CAS Application that needs to be updated
        CasAppUpdate body = ; // CasAppUpdate | 
        try {
            apiInstance.updateCasApp(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CasappApi#updateCasApp");
            e.printStackTrace();
        }
    }
}

confKey *confKey = ; // Configuration key of CAS Application that needs to be updated
CasAppUpdate *body = ; //  (optional)

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

// Updates a CAS Application.
[apiInstance updateCasAppWith:confKey
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.CasappApi()
var confKey = ; // {{confKey}} Configuration key of CAS Application that needs to be updated
var opts = { 
  'body':  // {{CasAppUpdate}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateCasApp(confKey, opts, callback);

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

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

            var apiInstance = new CasappApi();
            var confKey = new confKey(); // confKey | Configuration key of CAS Application that needs to be updated
            var body = new CasAppUpdate(); // CasAppUpdate |  (optional) 

            try
            {
                // Updates a CAS Application.
                apiInstance.updateCasApp(confKey, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CasappApi.updateCasApp: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCasappApi();
$confKey = ; // confKey | Configuration key of CAS Application that needs to be updated
$body = ; // CasAppUpdate | 

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

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

my $api_instance = WWW::SwaggerClient::CasappApi->new();
my $confKey = ; # confKey | Configuration key of CAS Application that needs to be updated
my $body = WWW::SwaggerClient::Object::CasAppUpdate->new(); # CasAppUpdate | 

eval { 
    $api_instance->updateCasApp(confKey => $confKey, body => $body);
};
if ($@) {
    warn "Exception when calling CasappApi->updateCasApp: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.CasappApi()
confKey =  # confKey | Configuration key of CAS Application that needs to be updated
body =  # CasAppUpdate |  (optional)

try: 
    # Updates a CAS Application.
    api_instance.update_cas_app(confKey, body=body)
except ApiException as e:
    print("Exception when calling CasappApi->updateCasApp: %s\n" % e)

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

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

public class Class2faApiExample {

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

import io.swagger.client.api.Class2faApi;

public class Class2faApiExample {

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

String *uid = uid_example; // 

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

// Delete all second factors for a user
[apiInstance deleteSecondFactorsWith:uid
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.Class2faApi()
var uid = uid_example; // {{String}} 

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

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

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

            var apiInstance = new Class2faApi();
            var uid = uid_example;  // String | 

            try
            {
                // Delete all second factors for a user
                apiInstance.deleteSecondFactors(uid);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class2faApi.deleteSecondFactors: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass2faApi();
$uid = uid_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::Class2faApi->new();
my $uid = uid_example; # String | 

eval { 
    $api_instance->deleteSecondFactors(uid => $uid);
};
if ($@) {
    warn "Exception when calling Class2faApi->deleteSecondFactors: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class2faApi()
uid = uid_example # String | 

try: 
    # Delete all second factors for a user
    api_instance.delete_second_factors(uid)
except ApiException as e:
    print("Exception when calling Class2faApi->deleteSecondFactors: %s\n" % e)

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

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

public class Class2faApiExample {

    public static void main(String[] args) {
        
        Class2faApi apiInstance = new Class2faApi();
        String uid = uid_example; // String | 
        String id = id_example; // String | 
        try {
            apiInstance.deleteSecondFactorsById(uid, id);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2faApi#deleteSecondFactorsById");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class2faApi;

public class Class2faApiExample {

    public static void main(String[] args) {
        Class2faApi apiInstance = new Class2faApi();
        String uid = uid_example; // String | 
        String id = id_example; // String | 
        try {
            apiInstance.deleteSecondFactorsById(uid, id);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2faApi#deleteSecondFactorsById");
            e.printStackTrace();
        }
    }
}

String *uid = uid_example; // 
String *id = id_example; // 

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

// Delete a second factors for a user
[apiInstance deleteSecondFactorsByIdWith:uid
    id:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.Class2faApi()
var uid = uid_example; // {{String}} 
var id = id_example; // {{String}} 

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

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

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

            var apiInstance = new Class2faApi();
            var uid = uid_example;  // String | 
            var id = id_example;  // String | 

            try
            {
                // Delete a second factors for a user
                apiInstance.deleteSecondFactorsById(uid, id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class2faApi.deleteSecondFactorsById: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass2faApi();
$uid = uid_example; // String | 
$id = id_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::Class2faApi->new();
my $uid = uid_example; # String | 
my $id = id_example; # String | 

eval { 
    $api_instance->deleteSecondFactorsById(uid => $uid, id => $id);
};
if ($@) {
    warn "Exception when calling Class2faApi->deleteSecondFactorsById: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class2faApi()
uid = uid_example # String | 
id = id_example # String | 

try: 
    # Delete a second factors for a user
    api_instance.delete_second_factors_by_id(uid, id)
except ApiException as e:
    print("Exception when calling Class2faApi->deleteSecondFactorsById: %s\n" % e)

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

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

public class Class2faApiExample {

    public static void main(String[] args) {
        
        Class2faApi apiInstance = new Class2faApi();
        String uid = uid_example; // String | 
        String type = type_example; // String | 
        try {
            apiInstance.deleteSecondFactorsByType(uid, type);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2faApi#deleteSecondFactorsByType");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class2faApi;

public class Class2faApiExample {

    public static void main(String[] args) {
        Class2faApi apiInstance = new Class2faApi();
        String uid = uid_example; // String | 
        String type = type_example; // String | 
        try {
            apiInstance.deleteSecondFactorsByType(uid, type);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2faApi#deleteSecondFactorsByType");
            e.printStackTrace();
        }
    }
}

String *uid = uid_example; // 
String *type = type_example; // 

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

// Delete all second factors of a given type for a user
[apiInstance deleteSecondFactorsByTypeWith:uid
    type:type
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.Class2faApi()
var uid = uid_example; // {{String}} 
var type = type_example; // {{String}} 

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

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

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

            var apiInstance = new Class2faApi();
            var uid = uid_example;  // String | 
            var type = type_example;  // String | 

            try
            {
                // Delete all second factors of a given type for a user
                apiInstance.deleteSecondFactorsByType(uid, type);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class2faApi.deleteSecondFactorsByType: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass2faApi();
$uid = uid_example; // String | 
$type = type_example; // String | 

try {
    $api_instance->deleteSecondFactorsByType($uid, $type);
} catch (Exception $e) {
    echo 'Exception when calling Class2faApi->deleteSecondFactorsByType: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class2faApi->new();
my $uid = uid_example; # String | 
my $type = type_example; # String | 

eval { 
    $api_instance->deleteSecondFactorsByType(uid => $uid, type => $type);
};
if ($@) {
    warn "Exception when calling Class2faApi->deleteSecondFactorsByType: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class2faApi()
uid = uid_example # String | 
type = type_example # String | 

try: 
    # Delete all second factors of a given type for a user
    api_instance.delete_second_factors_by_type(uid, type)
except ApiException as e:
    print("Exception when calling Class2faApi->deleteSecondFactorsByType: %s\n" % e)

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

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

public class Class2faApiExample {

    public static void main(String[] args) {
        
        Class2faApi apiInstance = new Class2faApi();
        String uid = uid_example; // String | 
        try {
            SecondFactors result = apiInstance.getSecondFactors(uid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2faApi#getSecondFactors");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class2faApi;

public class Class2faApiExample {

    public static void main(String[] args) {
        Class2faApi apiInstance = new Class2faApi();
        String uid = uid_example; // String | 
        try {
            SecondFactors result = apiInstance.getSecondFactors(uid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2faApi#getSecondFactors");
            e.printStackTrace();
        }
    }
}

String *uid = uid_example; // 

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

// List second factors for a user
[apiInstance getSecondFactorsWith:uid
              completionHandler: ^(SecondFactors output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.Class2faApi()
var uid = uid_example; // {{String}} 

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

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

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

            var apiInstance = new Class2faApi();
            var uid = uid_example;  // String | 

            try
            {
                // List second factors for a user
                SecondFactors result = apiInstance.getSecondFactors(uid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class2faApi.getSecondFactors: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass2faApi();
$uid = uid_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::Class2faApi->new();
my $uid = uid_example; # String | 

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

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

# create an instance of the API class
api_instance = swagger_client.Class2faApi()
uid = uid_example # String | 

try: 
    # List second factors for a user
    api_response = api_instance.get_second_factors(uid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class2faApi->getSecondFactors: %s\n" % e)

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

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

public class Class2faApiExample {

    public static void main(String[] args) {
        
        Class2faApi apiInstance = new Class2faApi();
        String uid = uid_example; // String | 
        String id = id_example; // String | 
        try {
            SecondFactors result = apiInstance.getSecondFactorsById(uid, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2faApi#getSecondFactorsById");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class2faApi;

public class Class2faApiExample {

    public static void main(String[] args) {
        Class2faApi apiInstance = new Class2faApi();
        String uid = uid_example; // String | 
        String id = id_example; // String | 
        try {
            SecondFactors result = apiInstance.getSecondFactorsById(uid, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2faApi#getSecondFactorsById");
            e.printStackTrace();
        }
    }
}

String *uid = uid_example; // 
String *id = id_example; // 

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

// Get second factors for a user given its ID
[apiInstance getSecondFactorsByIdWith:uid
    id:id
              completionHandler: ^(SecondFactors output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.Class2faApi()
var uid = uid_example; // {{String}} 
var id = id_example; // {{String}} 

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

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

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

            var apiInstance = new Class2faApi();
            var uid = uid_example;  // String | 
            var id = id_example;  // String | 

            try
            {
                // Get second factors for a user given its ID
                SecondFactors result = apiInstance.getSecondFactorsById(uid, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class2faApi.getSecondFactorsById: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass2faApi();
$uid = uid_example; // String | 
$id = id_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::Class2faApi->new();
my $uid = uid_example; # String | 
my $id = id_example; # String | 

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

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

# create an instance of the API class
api_instance = swagger_client.Class2faApi()
uid = uid_example # String | 
id = id_example # String | 

try: 
    # Get second factors for a user given its ID
    api_response = api_instance.get_second_factors_by_id(uid, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class2faApi->getSecondFactorsById: %s\n" % e)

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

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

public class Class2faApiExample {

    public static void main(String[] args) {
        
        Class2faApi apiInstance = new Class2faApi();
        String uid = uid_example; // String | 
        String type = type_example; // String | 
        try {
            SecondFactors result = apiInstance.getSecondFactorsByType(uid, type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2faApi#getSecondFactorsByType");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class2faApi;

public class Class2faApiExample {

    public static void main(String[] args) {
        Class2faApi apiInstance = new Class2faApi();
        String uid = uid_example; // String | 
        String type = type_example; // String | 
        try {
            SecondFactors result = apiInstance.getSecondFactorsByType(uid, type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2faApi#getSecondFactorsByType");
            e.printStackTrace();
        }
    }
}

String *uid = uid_example; // 
String *type = type_example; // 

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

// List second factors for a user given its type
[apiInstance getSecondFactorsByTypeWith:uid
    type:type
              completionHandler: ^(SecondFactors output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.Class2faApi()
var uid = uid_example; // {{String}} 
var type = type_example; // {{String}} 

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

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

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

            var apiInstance = new Class2faApi();
            var uid = uid_example;  // String | 
            var type = type_example;  // String | 

            try
            {
                // List second factors for a user given its type
                SecondFactors result = apiInstance.getSecondFactorsByType(uid, type);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class2faApi.getSecondFactorsByType: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass2faApi();
$uid = uid_example; // String | 
$type = type_example; // String | 

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

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

my $api_instance = WWW::SwaggerClient::Class2faApi->new();
my $uid = uid_example; # String | 
my $type = type_example; # String | 

eval { 
    my $result = $api_instance->getSecondFactorsByType(uid => $uid, type => $type);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class2faApi->getSecondFactorsByType: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class2faApi()
uid = uid_example # String | 
type = type_example # String | 

try: 
    # List second factors for a user given its type
    api_response = api_instance.get_second_factors_by_type(uid, type)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class2faApi->getSecondFactorsByType: %s\n" % e)

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

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

public class DefaultApiExample {

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

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

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

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

// Check the status of the API
[apiInstance statusWithCompletionHandler: 
              ^(Status output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

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

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

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

            var apiInstance = new DefaultApi();

            try
            {
                // Check the status of the API
                Status result = apiInstance.status();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.status: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    # Check the status of the API
    api_response = api_instance.status()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->status: %s\n" % e)

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

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

public class MenuappApiExample {

    public static void main(String[] args) {
        
        MenuappApi apiInstance = new MenuappApi();
        MenuApp body = ; // MenuApp | Menu Application to add
        menuCatConfKey cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
        try {
            apiInstance.addMenuApp(body, cat);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuappApi#addMenuApp");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MenuappApi;

public class MenuappApiExample {

    public static void main(String[] args) {
        MenuappApi apiInstance = new MenuappApi();
        MenuApp body = ; // MenuApp | Menu Application to add
        menuCatConfKey cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
        try {
            apiInstance.addMenuApp(body, cat);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuappApi#addMenuApp");
            e.printStackTrace();
        }
    }
}

MenuApp *body = ; // Menu Application to add
menuCatConfKey *cat = ; // Configuration key of Menu Category to work with

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

// Create a new Menu Application within a Menu Category
[apiInstance addMenuAppWith:body
    cat:cat
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.MenuappApi()
var body = ; // {{MenuApp}} Menu Application to add
var cat = ; // {{menuCatConfKey}} Configuration key of Menu Category to work with

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

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

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

            var apiInstance = new MenuappApi();
            var body = new MenuApp(); // MenuApp | Menu Application to add
            var cat = new menuCatConfKey(); // menuCatConfKey | Configuration key of Menu Category to work with

            try
            {
                // Create a new Menu Application within a Menu Category
                apiInstance.addMenuApp(body, cat);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MenuappApi.addMenuApp: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiMenuappApi();
$body = ; // MenuApp | Menu Application to add
$cat = ; // menuCatConfKey | Configuration key of Menu Category to work with

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

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

my $api_instance = WWW::SwaggerClient::MenuappApi->new();
my $body = WWW::SwaggerClient::Object::MenuApp->new(); # MenuApp | Menu Application to add
my $cat = ; # menuCatConfKey | Configuration key of Menu Category to work with

eval { 
    $api_instance->addMenuApp(body => $body, cat => $cat);
};
if ($@) {
    warn "Exception when calling MenuappApi->addMenuApp: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.MenuappApi()
body =  # MenuApp | Menu Application to add
cat =  # menuCatConfKey | Configuration key of Menu Category to work with

try: 
    # Create a new Menu Application within a Menu Category
    api_instance.add_menu_app(body, cat)
except ApiException as e:
    print("Exception when calling MenuappApi->addMenuApp: %s\n" % e)

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

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

public class MenuappApiExample {

    public static void main(String[] args) {
        
        MenuappApi apiInstance = new MenuappApi();
        menuCatConfKey cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
        confKey confKey = ; // confKey | Configuration key of Menu Application to delete
        try {
            apiInstance.deleteMenuApp(cat, confKey);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuappApi#deleteMenuApp");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MenuappApi;

public class MenuappApiExample {

    public static void main(String[] args) {
        MenuappApi apiInstance = new MenuappApi();
        menuCatConfKey cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
        confKey confKey = ; // confKey | Configuration key of Menu Application to delete
        try {
            apiInstance.deleteMenuApp(cat, confKey);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuappApi#deleteMenuApp");
            e.printStackTrace();
        }
    }
}

menuCatConfKey *cat = ; // Configuration key of Menu Category to work with
confKey *confKey = ; // Configuration key of Menu Application to delete

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

// Deletes a Menu Application
[apiInstance deleteMenuAppWith:cat
    confKey:confKey
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.MenuappApi()
var cat = ; // {{menuCatConfKey}} Configuration key of Menu Category to work with
var confKey = ; // {{confKey}} Configuration key of Menu Application to delete

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

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

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

            var apiInstance = new MenuappApi();
            var cat = new menuCatConfKey(); // menuCatConfKey | Configuration key of Menu Category to work with
            var confKey = new confKey(); // confKey | Configuration key of Menu Application to delete

            try
            {
                // Deletes a Menu Application
                apiInstance.deleteMenuApp(cat, confKey);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MenuappApi.deleteMenuApp: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiMenuappApi();
$cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
$confKey = ; // confKey | Configuration key of Menu Application to delete

try {
    $api_instance->deleteMenuApp($cat, $confKey);
} catch (Exception $e) {
    echo 'Exception when calling MenuappApi->deleteMenuApp: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::MenuappApi->new();
my $cat = ; # menuCatConfKey | Configuration key of Menu Category to work with
my $confKey = ; # confKey | Configuration key of Menu Application to delete

eval { 
    $api_instance->deleteMenuApp(cat => $cat, confKey => $confKey);
};
if ($@) {
    warn "Exception when calling MenuappApi->deleteMenuApp: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.MenuappApi()
cat =  # menuCatConfKey | Configuration key of Menu Category to work with
confKey =  # confKey | Configuration key of Menu Application to delete

try: 
    # Deletes a Menu Application
    api_instance.delete_menu_app(cat, confKey)
except ApiException as e:
    print("Exception when calling MenuappApi->deleteMenuApp: %s\n" % e)

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

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

public class MenuappApiExample {

    public static void main(String[] args) {
        
        MenuappApi apiInstance = new MenuappApi();
        menuCatConfKey cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
        String pattern = pattern_example; // String | Search pattern
        try {
            array[MenuApp] result = apiInstance.findMenuAppByConfKey(cat, pattern);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuappApi#findMenuAppByConfKey");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MenuappApi;

public class MenuappApiExample {

    public static void main(String[] args) {
        MenuappApi apiInstance = new MenuappApi();
        menuCatConfKey cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
        String pattern = pattern_example; // String | Search pattern
        try {
            array[MenuApp] result = apiInstance.findMenuAppByConfKey(cat, pattern);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuappApi#findMenuAppByConfKey");
            e.printStackTrace();
        }
    }
}

menuCatConfKey *cat = ; // Configuration key of Menu Category to work with
String *pattern = pattern_example; // Search pattern

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

// Finds Menu Applications by configuration key within a Menu Category
[apiInstance findMenuAppByConfKeyWith:cat
    pattern:pattern
              completionHandler: ^(array[MenuApp] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.MenuappApi()
var cat = ; // {{menuCatConfKey}} Configuration key of Menu Category to work with
var pattern = pattern_example; // {{String}} Search pattern

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

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

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

            var apiInstance = new MenuappApi();
            var cat = new menuCatConfKey(); // menuCatConfKey | Configuration key of Menu Category to work with
            var pattern = pattern_example;  // String | Search pattern

            try
            {
                // Finds Menu Applications by configuration key within a Menu Category
                array[MenuApp] result = apiInstance.findMenuAppByConfKey(cat, pattern);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MenuappApi.findMenuAppByConfKey: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiMenuappApi();
$cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
$pattern = pattern_example; // String | Search pattern

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

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

my $api_instance = WWW::SwaggerClient::MenuappApi->new();
my $cat = ; # menuCatConfKey | Configuration key of Menu Category to work with
my $pattern = pattern_example; # String | Search pattern

eval { 
    my $result = $api_instance->findMenuAppByConfKey(cat => $cat, pattern => $pattern);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MenuappApi->findMenuAppByConfKey: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.MenuappApi()
cat =  # menuCatConfKey | Configuration key of Menu Category to work with
pattern = pattern_example # String | Search pattern

try: 
    # Finds Menu Applications by configuration key within a Menu Category
    api_response = api_instance.find_menu_app_by_conf_key(cat, pattern)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MenuappApi->findMenuAppByConfKey: %s\n" % e)

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

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

public class MenuappApiExample {

    public static void main(String[] args) {
        
        MenuappApi apiInstance = new MenuappApi();
        menuCatConfKey cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
        confKey confKey = ; // confKey | Configuration key of Menu Application
        try {
            MenuApp result = apiInstance.getMenuAppByConfKey(cat, confKey);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuappApi#getMenuAppByConfKey");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MenuappApi;

public class MenuappApiExample {

    public static void main(String[] args) {
        MenuappApi apiInstance = new MenuappApi();
        menuCatConfKey cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
        confKey confKey = ; // confKey | Configuration key of Menu Application
        try {
            MenuApp result = apiInstance.getMenuAppByConfKey(cat, confKey);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuappApi#getMenuAppByConfKey");
            e.printStackTrace();
        }
    }
}

menuCatConfKey *cat = ; // Configuration key of Menu Category to work with
confKey *confKey = ; // Configuration key of Menu Application

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

// Get Menu Application within a Menu Category by configuration key
[apiInstance getMenuAppByConfKeyWith:cat
    confKey:confKey
              completionHandler: ^(MenuApp output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.MenuappApi()
var cat = ; // {{menuCatConfKey}} Configuration key of Menu Category to work with
var confKey = ; // {{confKey}} Configuration key of Menu Application

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

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

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

            var apiInstance = new MenuappApi();
            var cat = new menuCatConfKey(); // menuCatConfKey | Configuration key of Menu Category to work with
            var confKey = new confKey(); // confKey | Configuration key of Menu Application

            try
            {
                // Get Menu Application within a Menu Category by configuration key
                MenuApp result = apiInstance.getMenuAppByConfKey(cat, confKey);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MenuappApi.getMenuAppByConfKey: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiMenuappApi();
$cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
$confKey = ; // confKey | Configuration key of Menu Application

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

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

my $api_instance = WWW::SwaggerClient::MenuappApi->new();
my $cat = ; # menuCatConfKey | Configuration key of Menu Category to work with
my $confKey = ; # confKey | Configuration key of Menu Application

eval { 
    my $result = $api_instance->getMenuAppByConfKey(cat => $cat, confKey => $confKey);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MenuappApi->getMenuAppByConfKey: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.MenuappApi()
cat =  # menuCatConfKey | Configuration key of Menu Category to work with
confKey =  # confKey | Configuration key of Menu Application

try: 
    # Get Menu Application within a Menu Category by configuration key
    api_response = api_instance.get_menu_app_by_conf_key(cat, confKey)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MenuappApi->getMenuAppByConfKey: %s\n" % e)

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

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

public class MenuappApiExample {

    public static void main(String[] args) {
        
        MenuappApi apiInstance = new MenuappApi();
        menuCatConfKey cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
        try {
            array[MenuApp] result = apiInstance.getMenuApps(cat);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuappApi#getMenuApps");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MenuappApi;

public class MenuappApiExample {

    public static void main(String[] args) {
        MenuappApi apiInstance = new MenuappApi();
        menuCatConfKey cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
        try {
            array[MenuApp] result = apiInstance.getMenuApps(cat);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuappApi#getMenuApps");
            e.printStackTrace();
        }
    }
}

menuCatConfKey *cat = ; // Configuration key of Menu Category to work with

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

// Get Menu Applications within a Menu Category
[apiInstance getMenuAppsWith:cat
              completionHandler: ^(array[MenuApp] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.MenuappApi()
var cat = ; // {{menuCatConfKey}} Configuration key of Menu Category to work with

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

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

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

            var apiInstance = new MenuappApi();
            var cat = new menuCatConfKey(); // menuCatConfKey | Configuration key of Menu Category to work with

            try
            {
                // Get Menu Applications within a Menu Category
                array[MenuApp] result = apiInstance.getMenuApps(cat);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MenuappApi.getMenuApps: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiMenuappApi();
$cat = ; // menuCatConfKey | Configuration key of Menu Category to work with

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

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

my $api_instance = WWW::SwaggerClient::MenuappApi->new();
my $cat = ; # menuCatConfKey | Configuration key of Menu Category to work with

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

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

# create an instance of the API class
api_instance = swagger_client.MenuappApi()
cat =  # menuCatConfKey | Configuration key of Menu Category to work with

try: 
    # Get Menu Applications within a Menu Category
    api_response = api_instance.get_menu_apps(cat)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MenuappApi->getMenuApps: %s\n" % e)

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

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

public class MenuappApiExample {

    public static void main(String[] args) {
        
        MenuappApi apiInstance = new MenuappApi();
        menuCatConfKey cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
        confKey confKey = ; // confKey | Configuration key of Menu Application that needs to be replaced
        MenuApp body = ; // MenuApp | 
        try {
            apiInstance.replaceMenuApp(cat, confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuappApi#replaceMenuApp");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MenuappApi;

public class MenuappApiExample {

    public static void main(String[] args) {
        MenuappApi apiInstance = new MenuappApi();
        menuCatConfKey cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
        confKey confKey = ; // confKey | Configuration key of Menu Application that needs to be replaced
        MenuApp body = ; // MenuApp | 
        try {
            apiInstance.replaceMenuApp(cat, confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuappApi#replaceMenuApp");
            e.printStackTrace();
        }
    }
}

menuCatConfKey *cat = ; // Configuration key of Menu Category to work with
confKey *confKey = ; // Configuration key of Menu Application that needs to be replaced
MenuApp *body = ; //  (optional)

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

// Replaces a Menu Application
[apiInstance replaceMenuAppWith:cat
    confKey:confKey
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.MenuappApi()
var cat = ; // {{menuCatConfKey}} Configuration key of Menu Category to work with
var confKey = ; // {{confKey}} Configuration key of Menu Application that needs to be replaced
var opts = { 
  'body':  // {{MenuApp}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.replaceMenuApp(catconfKey, opts, callback);

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

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

            var apiInstance = new MenuappApi();
            var cat = new menuCatConfKey(); // menuCatConfKey | Configuration key of Menu Category to work with
            var confKey = new confKey(); // confKey | Configuration key of Menu Application that needs to be replaced
            var body = new MenuApp(); // MenuApp |  (optional) 

            try
            {
                // Replaces a Menu Application
                apiInstance.replaceMenuApp(cat, confKey, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MenuappApi.replaceMenuApp: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiMenuappApi();
$cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
$confKey = ; // confKey | Configuration key of Menu Application that needs to be replaced
$body = ; // MenuApp | 

try {
    $api_instance->replaceMenuApp($cat, $confKey, $body);
} catch (Exception $e) {
    echo 'Exception when calling MenuappApi->replaceMenuApp: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::MenuappApi->new();
my $cat = ; # menuCatConfKey | Configuration key of Menu Category to work with
my $confKey = ; # confKey | Configuration key of Menu Application that needs to be replaced
my $body = WWW::SwaggerClient::Object::MenuApp->new(); # MenuApp | 

eval { 
    $api_instance->replaceMenuApp(cat => $cat, confKey => $confKey, body => $body);
};
if ($@) {
    warn "Exception when calling MenuappApi->replaceMenuApp: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.MenuappApi()
cat =  # menuCatConfKey | Configuration key of Menu Category to work with
confKey =  # confKey | Configuration key of Menu Application that needs to be replaced
body =  # MenuApp |  (optional)

try: 
    # Replaces a Menu Application
    api_instance.replace_menu_app(cat, confKey, body=body)
except ApiException as e:
    print("Exception when calling MenuappApi->replaceMenuApp: %s\n" % e)

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

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

public class MenuappApiExample {

    public static void main(String[] args) {
        
        MenuappApi apiInstance = new MenuappApi();
        menuCatConfKey cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
        confKey confKey = ; // confKey | Configuration key of Menu Application that needs to be updated
        MenuAppUpdate body = ; // MenuAppUpdate | 
        try {
            apiInstance.updateMenuApp(cat, confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuappApi#updateMenuApp");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MenuappApi;

public class MenuappApiExample {

    public static void main(String[] args) {
        MenuappApi apiInstance = new MenuappApi();
        menuCatConfKey cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
        confKey confKey = ; // confKey | Configuration key of Menu Application that needs to be updated
        MenuAppUpdate body = ; // MenuAppUpdate | 
        try {
            apiInstance.updateMenuApp(cat, confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuappApi#updateMenuApp");
            e.printStackTrace();
        }
    }
}

menuCatConfKey *cat = ; // Configuration key of Menu Category to work with
confKey *confKey = ; // Configuration key of Menu Application that needs to be updated
MenuAppUpdate *body = ; //  (optional)

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

// Updates a Menu Application
[apiInstance updateMenuAppWith:cat
    confKey:confKey
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.MenuappApi()
var cat = ; // {{menuCatConfKey}} Configuration key of Menu Category to work with
var confKey = ; // {{confKey}} Configuration key of Menu Application that needs to be updated
var opts = { 
  'body':  // {{MenuAppUpdate}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateMenuApp(catconfKey, opts, callback);

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

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

            var apiInstance = new MenuappApi();
            var cat = new menuCatConfKey(); // menuCatConfKey | Configuration key of Menu Category to work with
            var confKey = new confKey(); // confKey | Configuration key of Menu Application that needs to be updated
            var body = new MenuAppUpdate(); // MenuAppUpdate |  (optional) 

            try
            {
                // Updates a Menu Application
                apiInstance.updateMenuApp(cat, confKey, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MenuappApi.updateMenuApp: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiMenuappApi();
$cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
$confKey = ; // confKey | Configuration key of Menu Application that needs to be updated
$body = ; // MenuAppUpdate | 

try {
    $api_instance->updateMenuApp($cat, $confKey, $body);
} catch (Exception $e) {
    echo 'Exception when calling MenuappApi->updateMenuApp: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::MenuappApi->new();
my $cat = ; # menuCatConfKey | Configuration key of Menu Category to work with
my $confKey = ; # confKey | Configuration key of Menu Application that needs to be updated
my $body = WWW::SwaggerClient::Object::MenuAppUpdate->new(); # MenuAppUpdate | 

eval { 
    $api_instance->updateMenuApp(cat => $cat, confKey => $confKey, body => $body);
};
if ($@) {
    warn "Exception when calling MenuappApi->updateMenuApp: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.MenuappApi()
cat =  # menuCatConfKey | Configuration key of Menu Category to work with
confKey =  # confKey | Configuration key of Menu Application that needs to be updated
body =  # MenuAppUpdate |  (optional)

try: 
    # Updates a Menu Application
    api_instance.update_menu_app(cat, confKey, body=body)
except ApiException as e:
    print("Exception when calling MenuappApi->updateMenuApp: %s\n" % e)

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

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

public class MenucatApiExample {

    public static void main(String[] args) {
        
        MenucatApi apiInstance = new MenucatApi();
        MenuCat body = ; // MenuCat | Menu Category to add
        try {
            apiInstance.addMenuCat(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenucatApi#addMenuCat");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MenucatApi;

public class MenucatApiExample {

    public static void main(String[] args) {
        MenucatApi apiInstance = new MenucatApi();
        MenuCat body = ; // MenuCat | Menu Category to add
        try {
            apiInstance.addMenuCat(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenucatApi#addMenuCat");
            e.printStackTrace();
        }
    }
}

MenuCat *body = ; // Menu Category to add

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

// Create a new Menu Category
[apiInstance addMenuCatWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.MenucatApi()
var body = ; // {{MenuCat}} Menu Category to add

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

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

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

            var apiInstance = new MenucatApi();
            var body = new MenuCat(); // MenuCat | Menu Category to add

            try
            {
                // Create a new Menu Category
                apiInstance.addMenuCat(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MenucatApi.addMenuCat: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiMenucatApi();
$body = ; // MenuCat | Menu Category to add

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

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

my $api_instance = WWW::SwaggerClient::MenucatApi->new();
my $body = WWW::SwaggerClient::Object::MenuCat->new(); # MenuCat | Menu Category to add

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

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

# create an instance of the API class
api_instance = swagger_client.MenucatApi()
body =  # MenuCat | Menu Category to add

try: 
    # Create a new Menu Category
    api_instance.add_menu_cat(body)
except ApiException as e:
    print("Exception when calling MenucatApi->addMenuCat: %s\n" % e)

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

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

public class MenucatApiExample {

    public static void main(String[] args) {
        
        MenucatApi apiInstance = new MenucatApi();
        confKey confKey = ; // confKey | Configuration key of Menu Category to delete
        try {
            apiInstance.deleteMenuCat(confKey);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenucatApi#deleteMenuCat");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MenucatApi;

public class MenucatApiExample {

    public static void main(String[] args) {
        MenucatApi apiInstance = new MenucatApi();
        confKey confKey = ; // confKey | Configuration key of Menu Category to delete
        try {
            apiInstance.deleteMenuCat(confKey);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenucatApi#deleteMenuCat");
            e.printStackTrace();
        }
    }
}

confKey *confKey = ; // Configuration key of Menu Category to delete

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

// Deletes a Menu Category
[apiInstance deleteMenuCatWith:confKey
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.MenucatApi()
var confKey = ; // {{confKey}} Configuration key of Menu Category to delete

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

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

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

            var apiInstance = new MenucatApi();
            var confKey = new confKey(); // confKey | Configuration key of Menu Category to delete

            try
            {
                // Deletes a Menu Category
                apiInstance.deleteMenuCat(confKey);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MenucatApi.deleteMenuCat: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiMenucatApi();
$confKey = ; // confKey | Configuration key of Menu Category to delete

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

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

my $api_instance = WWW::SwaggerClient::MenucatApi->new();
my $confKey = ; # confKey | Configuration key of Menu Category to delete

eval { 
    $api_instance->deleteMenuCat(confKey => $confKey);
};
if ($@) {
    warn "Exception when calling MenucatApi->deleteMenuCat: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.MenucatApi()
confKey =  # confKey | Configuration key of Menu Category to delete

try: 
    # Deletes a Menu Category
    api_instance.delete_menu_cat(confKey)
except ApiException as e:
    print("Exception when calling MenucatApi->deleteMenuCat: %s\n" % e)

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

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

public class MenucatApiExample {

    public static void main(String[] args) {
        
        MenucatApi apiInstance = new MenucatApi();
        String pattern = pattern_example; // String | Search pattern
        try {
            array[MenuCat] result = apiInstance.findMenuCatByConfKey(pattern);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenucatApi#findMenuCatByConfKey");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MenucatApi;

public class MenucatApiExample {

    public static void main(String[] args) {
        MenucatApi apiInstance = new MenucatApi();
        String pattern = pattern_example; // String | Search pattern
        try {
            array[MenuCat] result = apiInstance.findMenuCatByConfKey(pattern);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenucatApi#findMenuCatByConfKey");
            e.printStackTrace();
        }
    }
}

String *pattern = pattern_example; // Search pattern

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

// Finds Menu Categories by configuration key
[apiInstance findMenuCatByConfKeyWith:pattern
              completionHandler: ^(array[MenuCat] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.MenucatApi()
var pattern = pattern_example; // {{String}} Search pattern

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

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

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

            var apiInstance = new MenucatApi();
            var pattern = pattern_example;  // String | Search pattern

            try
            {
                // Finds Menu Categories by configuration key
                array[MenuCat] result = apiInstance.findMenuCatByConfKey(pattern);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MenucatApi.findMenuCatByConfKey: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiMenucatApi();
$pattern = pattern_example; // String | Search pattern

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

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

my $api_instance = WWW::SwaggerClient::MenucatApi->new();
my $pattern = pattern_example; # String | Search pattern

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

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

# create an instance of the API class
api_instance = swagger_client.MenucatApi()
pattern = pattern_example # String | Search pattern

try: 
    # Finds Menu Categories by configuration key
    api_response = api_instance.find_menu_cat_by_conf_key(pattern)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MenucatApi->findMenuCatByConfKey: %s\n" % e)

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

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

public class MenucatApiExample {

    public static void main(String[] args) {
        
        MenucatApi apiInstance = new MenucatApi();
        confKey confKey = ; // confKey | Configuration key of Menu Category
        try {
            MenuCat result = apiInstance.getMenuCatByConfKey(confKey);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenucatApi#getMenuCatByConfKey");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MenucatApi;

public class MenucatApiExample {

    public static void main(String[] args) {
        MenucatApi apiInstance = new MenucatApi();
        confKey confKey = ; // confKey | Configuration key of Menu Category
        try {
            MenuCat result = apiInstance.getMenuCatByConfKey(confKey);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenucatApi#getMenuCatByConfKey");
            e.printStackTrace();
        }
    }
}

confKey *confKey = ; // Configuration key of Menu Category

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

// Get Menu Category by configuration key
[apiInstance getMenuCatByConfKeyWith:confKey
              completionHandler: ^(MenuCat output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.MenucatApi()
var confKey = ; // {{confKey}} Configuration key of Menu Category

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

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

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

            var apiInstance = new MenucatApi();
            var confKey = new confKey(); // confKey | Configuration key of Menu Category

            try
            {
                // Get Menu Category by configuration key
                MenuCat result = apiInstance.getMenuCatByConfKey(confKey);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MenucatApi.getMenuCatByConfKey: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiMenucatApi();
$confKey = ; // confKey | Configuration key of Menu Category

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

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

my $api_instance = WWW::SwaggerClient::MenucatApi->new();
my $confKey = ; # confKey | Configuration key of Menu Category

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

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

# create an instance of the API class
api_instance = swagger_client.MenucatApi()
confKey =  # confKey | Configuration key of Menu Category

try: 
    # Get Menu Category by configuration key
    api_response = api_instance.get_menu_cat_by_conf_key(confKey)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MenucatApi->getMenuCatByConfKey: %s\n" % e)

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

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

public class MenucatApiExample {

    public static void main(String[] args) {
        
        MenucatApi apiInstance = new MenucatApi();
        confKey confKey = ; // confKey | Configuration key of Menu Category that needs to be replaced
        MenuCat body = ; // MenuCat | 
        try {
            apiInstance.replaceMenuCat(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenucatApi#replaceMenuCat");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MenucatApi;

public class MenucatApiExample {

    public static void main(String[] args) {
        MenucatApi apiInstance = new MenucatApi();
        confKey confKey = ; // confKey | Configuration key of Menu Category that needs to be replaced
        MenuCat body = ; // MenuCat | 
        try {
            apiInstance.replaceMenuCat(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenucatApi#replaceMenuCat");
            e.printStackTrace();
        }
    }
}

confKey *confKey = ; // Configuration key of Menu Category that needs to be replaced
MenuCat *body = ; //  (optional)

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

// Replaces a Menu Category
[apiInstance replaceMenuCatWith:confKey
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.MenucatApi()
var confKey = ; // {{confKey}} Configuration key of Menu Category that needs to be replaced
var opts = { 
  'body':  // {{MenuCat}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.replaceMenuCat(confKey, opts, callback);

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

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

            var apiInstance = new MenucatApi();
            var confKey = new confKey(); // confKey | Configuration key of Menu Category that needs to be replaced
            var body = new MenuCat(); // MenuCat |  (optional) 

            try
            {
                // Replaces a Menu Category
                apiInstance.replaceMenuCat(confKey, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MenucatApi.replaceMenuCat: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiMenucatApi();
$confKey = ; // confKey | Configuration key of Menu Category that needs to be replaced
$body = ; // MenuCat | 

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

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

my $api_instance = WWW::SwaggerClient::MenucatApi->new();
my $confKey = ; # confKey | Configuration key of Menu Category that needs to be replaced
my $body = WWW::SwaggerClient::Object::MenuCat->new(); # MenuCat | 

eval { 
    $api_instance->replaceMenuCat(confKey => $confKey, body => $body);
};
if ($@) {
    warn "Exception when calling MenucatApi->replaceMenuCat: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.MenucatApi()
confKey =  # confKey | Configuration key of Menu Category that needs to be replaced
body =  # MenuCat |  (optional)

try: 
    # Replaces a Menu Category
    api_instance.replace_menu_cat(confKey, body=body)
except ApiException as e:
    print("Exception when calling MenucatApi->replaceMenuCat: %s\n" % e)

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

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

public class MenucatApiExample {

    public static void main(String[] args) {
        
        MenucatApi apiInstance = new MenucatApi();
        confKey confKey = ; // confKey | Configuration key of Menu Category that needs to be updated
        MenuCatUpdate body = ; // MenuCatUpdate | 
        try {
            apiInstance.updateMenuCat(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenucatApi#updateMenuCat");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MenucatApi;

public class MenucatApiExample {

    public static void main(String[] args) {
        MenucatApi apiInstance = new MenucatApi();
        confKey confKey = ; // confKey | Configuration key of Menu Category that needs to be updated
        MenuCatUpdate body = ; // MenuCatUpdate | 
        try {
            apiInstance.updateMenuCat(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenucatApi#updateMenuCat");
            e.printStackTrace();
        }
    }
}

confKey *confKey = ; // Configuration key of Menu Category that needs to be updated
MenuCatUpdate *body = ; //  (optional)

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

// Updates a Menu Category
[apiInstance updateMenuCatWith:confKey
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.MenucatApi()
var confKey = ; // {{confKey}} Configuration key of Menu Category that needs to be updated
var opts = { 
  'body':  // {{MenuCatUpdate}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateMenuCat(confKey, opts, callback);

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

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

            var apiInstance = new MenucatApi();
            var confKey = new confKey(); // confKey | Configuration key of Menu Category that needs to be updated
            var body = new MenuCatUpdate(); // MenuCatUpdate |  (optional) 

            try
            {
                // Updates a Menu Category
                apiInstance.updateMenuCat(confKey, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MenucatApi.updateMenuCat: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiMenucatApi();
$confKey = ; // confKey | Configuration key of Menu Category that needs to be updated
$body = ; // MenuCatUpdate | 

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

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

my $api_instance = WWW::SwaggerClient::MenucatApi->new();
my $confKey = ; # confKey | Configuration key of Menu Category that needs to be updated
my $body = WWW::SwaggerClient::Object::MenuCatUpdate->new(); # MenuCatUpdate | 

eval { 
    $api_instance->updateMenuCat(confKey => $confKey, body => $body);
};
if ($@) {
    warn "Exception when calling MenucatApi->updateMenuCat: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.MenucatApi()
confKey =  # confKey | Configuration key of Menu Category that needs to be updated
body =  # MenuCatUpdate |  (optional)

try: 
    # Updates a Menu Category
    api_instance.update_menu_cat(confKey, body=body)
except ApiException as e:
    print("Exception when calling MenucatApi->updateMenuCat: %s\n" % e)

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

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

public class OidcrpApiExample {

    public static void main(String[] args) {
        
        OidcrpApi apiInstance = new OidcrpApi();
        OidcRp body = ; // OidcRp | OpenID Connect Relaying Party to add
        try {
            apiInstance.addoidcrp(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OidcrpApi#addoidcrp");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OidcrpApi;

public class OidcrpApiExample {

    public static void main(String[] args) {
        OidcrpApi apiInstance = new OidcrpApi();
        OidcRp body = ; // OidcRp | OpenID Connect Relaying Party to add
        try {
            apiInstance.addoidcrp(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OidcrpApi#addoidcrp");
            e.printStackTrace();
        }
    }
}

OidcRp *body = ; // OpenID Connect Relaying Party to add

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

// Create a new OpenID Connect Relaying Party
[apiInstance addoidcrpWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.OidcrpApi()
var body = ; // {{OidcRp}} OpenID Connect Relaying Party to add

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

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

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

            var apiInstance = new OidcrpApi();
            var body = new OidcRp(); // OidcRp | OpenID Connect Relaying Party to add

            try
            {
                // Create a new OpenID Connect Relaying Party
                apiInstance.addoidcrp(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OidcrpApi.addoidcrp: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiOidcrpApi();
$body = ; // OidcRp | OpenID Connect Relaying Party to add

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

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

my $api_instance = WWW::SwaggerClient::OidcrpApi->new();
my $body = WWW::SwaggerClient::Object::OidcRp->new(); # OidcRp | OpenID Connect Relaying Party to add

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

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

# create an instance of the API class
api_instance = swagger_client.OidcrpApi()
body =  # OidcRp | OpenID Connect Relaying Party to add

try: 
    # Create a new OpenID Connect Relaying Party
    api_instance.addoidcrp(body)
except ApiException as e:
    print("Exception when calling OidcrpApi->addoidcrp: %s\n" % e)

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

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

public class OidcrpApiExample {

    public static void main(String[] args) {
        
        OidcrpApi apiInstance = new OidcrpApi();
        confKey confKey = ; // confKey | Configuration key of OpenID Connect Relaying Party to delete
        try {
            apiInstance.deleteOidcRp(confKey);
        } catch (ApiException e) {
            System.err.println("Exception when calling OidcrpApi#deleteOidcRp");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OidcrpApi;

public class OidcrpApiExample {

    public static void main(String[] args) {
        OidcrpApi apiInstance = new OidcrpApi();
        confKey confKey = ; // confKey | Configuration key of OpenID Connect Relaying Party to delete
        try {
            apiInstance.deleteOidcRp(confKey);
        } catch (ApiException e) {
            System.err.println("Exception when calling OidcrpApi#deleteOidcRp");
            e.printStackTrace();
        }
    }
}

confKey *confKey = ; // Configuration key of OpenID Connect Relaying Party to delete

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

// Deletes a OpenID Connect Relaying Party
[apiInstance deleteOidcRpWith:confKey
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.OidcrpApi()
var confKey = ; // {{confKey}} Configuration key of OpenID Connect Relaying Party to delete

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

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

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

            var apiInstance = new OidcrpApi();
            var confKey = new confKey(); // confKey | Configuration key of OpenID Connect Relaying Party to delete

            try
            {
                // Deletes a OpenID Connect Relaying Party
                apiInstance.deleteOidcRp(confKey);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OidcrpApi.deleteOidcRp: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiOidcrpApi();
$confKey = ; // confKey | Configuration key of OpenID Connect Relaying Party to delete

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

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

my $api_instance = WWW::SwaggerClient::OidcrpApi->new();
my $confKey = ; # confKey | Configuration key of OpenID Connect Relaying Party to delete

eval { 
    $api_instance->deleteOidcRp(confKey => $confKey);
};
if ($@) {
    warn "Exception when calling OidcrpApi->deleteOidcRp: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.OidcrpApi()
confKey =  # confKey | Configuration key of OpenID Connect Relaying Party to delete

try: 
    # Deletes a OpenID Connect Relaying Party
    api_instance.delete_oidc_rp(confKey)
except ApiException as e:
    print("Exception when calling OidcrpApi->deleteOidcRp: %s\n" % e)

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

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

public class OidcrpApiExample {

    public static void main(String[] args) {
        
        OidcrpApi apiInstance = new OidcrpApi();
        String clientId = clientId_example; // String | Client ID to search
        try {
            OidcRp result = apiInstance.findOidcRpByClientId(clientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OidcrpApi#findOidcRpByClientId");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OidcrpApi;

public class OidcrpApiExample {

    public static void main(String[] args) {
        OidcrpApi apiInstance = new OidcrpApi();
        String clientId = clientId_example; // String | Client ID to search
        try {
            OidcRp result = apiInstance.findOidcRpByClientId(clientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OidcrpApi#findOidcRpByClientId");
            e.printStackTrace();
        }
    }
}

String *clientId = clientId_example; // Client ID to search

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

// Finds OpenID Connect Relaying Party by Client ID
[apiInstance findOidcRpByClientIdWith:clientId
              completionHandler: ^(OidcRp output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.OidcrpApi()
var clientId = clientId_example; // {{String}} Client ID to search

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

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

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

            var apiInstance = new OidcrpApi();
            var clientId = clientId_example;  // String | Client ID to search

            try
            {
                // Finds OpenID Connect Relaying Party by Client ID
                OidcRp result = apiInstance.findOidcRpByClientId(clientId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OidcrpApi.findOidcRpByClientId: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiOidcrpApi();
$clientId = clientId_example; // String | Client ID to search

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

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

my $api_instance = WWW::SwaggerClient::OidcrpApi->new();
my $clientId = clientId_example; # String | Client ID to search

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

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

# create an instance of the API class
api_instance = swagger_client.OidcrpApi()
clientId = clientId_example # String | Client ID to search

try: 
    # Finds OpenID Connect Relaying Party by Client ID
    api_response = api_instance.find_oidc_rp_by_client_id(clientId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OidcrpApi->findOidcRpByClientId: %s\n" % e)

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

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

public class OidcrpApiExample {

    public static void main(String[] args) {
        
        OidcrpApi apiInstance = new OidcrpApi();
        confKey pattern = ; // confKey | Search pattern
        try {
            array[OidcRp] result = apiInstance.findOidcRpByConfKey(pattern);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OidcrpApi#findOidcRpByConfKey");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OidcrpApi;

public class OidcrpApiExample {

    public static void main(String[] args) {
        OidcrpApi apiInstance = new OidcrpApi();
        confKey pattern = ; // confKey | Search pattern
        try {
            array[OidcRp] result = apiInstance.findOidcRpByConfKey(pattern);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OidcrpApi#findOidcRpByConfKey");
            e.printStackTrace();
        }
    }
}

confKey *pattern = ; // Search pattern

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

// Finds OpenID Connect Relaying Partys by configuration key
[apiInstance findOidcRpByConfKeyWith:pattern
              completionHandler: ^(array[OidcRp] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.OidcrpApi()
var pattern = ; // {{confKey}} Search pattern

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

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

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

            var apiInstance = new OidcrpApi();
            var pattern = new confKey(); // confKey | Search pattern

            try
            {
                // Finds OpenID Connect Relaying Partys by configuration key
                array[OidcRp] result = apiInstance.findOidcRpByConfKey(pattern);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OidcrpApi.findOidcRpByConfKey: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiOidcrpApi();
$pattern = ; // confKey | Search pattern

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

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

my $api_instance = WWW::SwaggerClient::OidcrpApi->new();
my $pattern = ; # confKey | Search pattern

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

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

# create an instance of the API class
api_instance = swagger_client.OidcrpApi()
pattern =  # confKey | Search pattern

try: 
    # Finds OpenID Connect Relaying Partys by configuration key
    api_response = api_instance.find_oidc_rp_by_conf_key(pattern)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OidcrpApi->findOidcRpByConfKey: %s\n" % e)

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

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

public class OidcrpApiExample {

    public static void main(String[] args) {
        
        OidcrpApi apiInstance = new OidcrpApi();
        confKey confKey = ; // confKey | Configuration key of OpenID Connect Relaying Party
        try {
            OidcRp result = apiInstance.getOidcRpByConfKey(confKey);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OidcrpApi#getOidcRpByConfKey");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OidcrpApi;

public class OidcrpApiExample {

    public static void main(String[] args) {
        OidcrpApi apiInstance = new OidcrpApi();
        confKey confKey = ; // confKey | Configuration key of OpenID Connect Relaying Party
        try {
            OidcRp result = apiInstance.getOidcRpByConfKey(confKey);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OidcrpApi#getOidcRpByConfKey");
            e.printStackTrace();
        }
    }
}

confKey *confKey = ; // Configuration key of OpenID Connect Relaying Party

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

// Get OpenID Connect Relaying Party by configuration key
[apiInstance getOidcRpByConfKeyWith:confKey
              completionHandler: ^(OidcRp output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.OidcrpApi()
var confKey = ; // {{confKey}} Configuration key of OpenID Connect Relaying Party

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

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

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

            var apiInstance = new OidcrpApi();
            var confKey = new confKey(); // confKey | Configuration key of OpenID Connect Relaying Party

            try
            {
                // Get OpenID Connect Relaying Party by configuration key
                OidcRp result = apiInstance.getOidcRpByConfKey(confKey);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OidcrpApi.getOidcRpByConfKey: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiOidcrpApi();
$confKey = ; // confKey | Configuration key of OpenID Connect Relaying Party

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

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

my $api_instance = WWW::SwaggerClient::OidcrpApi->new();
my $confKey = ; # confKey | Configuration key of OpenID Connect Relaying Party

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

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

# create an instance of the API class
api_instance = swagger_client.OidcrpApi()
confKey =  # confKey | Configuration key of OpenID Connect Relaying Party

try: 
    # Get OpenID Connect Relaying Party by configuration key
    api_response = api_instance.get_oidc_rp_by_conf_key(confKey)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OidcrpApi->getOidcRpByConfKey: %s\n" % e)

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

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

public class OidcrpApiExample {

    public static void main(String[] args) {
        
        OidcrpApi apiInstance = new OidcrpApi();
        confKey confKey = ; // confKey | Configuration key of OpenID Connect Relaying Party that needs to be replaced
        OidcRpReplace body = ; // OidcRpReplace | 
        try {
            apiInstance.replaceOidcRp(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OidcrpApi#replaceOidcRp");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OidcrpApi;

public class OidcrpApiExample {

    public static void main(String[] args) {
        OidcrpApi apiInstance = new OidcrpApi();
        confKey confKey = ; // confKey | Configuration key of OpenID Connect Relaying Party that needs to be replaced
        OidcRpReplace body = ; // OidcRpReplace | 
        try {
            apiInstance.replaceOidcRp(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OidcrpApi#replaceOidcRp");
            e.printStackTrace();
        }
    }
}

confKey *confKey = ; // Configuration key of OpenID Connect Relaying Party that needs to be replaced
OidcRpReplace *body = ; //  (optional)

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

// Replaces an OpenID Connect Relaying Party
[apiInstance replaceOidcRpWith:confKey
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.OidcrpApi()
var confKey = ; // {{confKey}} Configuration key of OpenID Connect Relaying Party that needs to be replaced
var opts = { 
  'body':  // {{OidcRpReplace}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.replaceOidcRp(confKey, opts, callback);

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

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

            var apiInstance = new OidcrpApi();
            var confKey = new confKey(); // confKey | Configuration key of OpenID Connect Relaying Party that needs to be replaced
            var body = new OidcRpReplace(); // OidcRpReplace |  (optional) 

            try
            {
                // Replaces an OpenID Connect Relaying Party
                apiInstance.replaceOidcRp(confKey, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OidcrpApi.replaceOidcRp: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiOidcrpApi();
$confKey = ; // confKey | Configuration key of OpenID Connect Relaying Party that needs to be replaced
$body = ; // OidcRpReplace | 

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

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

my $api_instance = WWW::SwaggerClient::OidcrpApi->new();
my $confKey = ; # confKey | Configuration key of OpenID Connect Relaying Party that needs to be replaced
my $body = WWW::SwaggerClient::Object::OidcRpReplace->new(); # OidcRpReplace | 

eval { 
    $api_instance->replaceOidcRp(confKey => $confKey, body => $body);
};
if ($@) {
    warn "Exception when calling OidcrpApi->replaceOidcRp: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.OidcrpApi()
confKey =  # confKey | Configuration key of OpenID Connect Relaying Party that needs to be replaced
body =  # OidcRpReplace |  (optional)

try: 
    # Replaces an OpenID Connect Relaying Party
    api_instance.replace_oidc_rp(confKey, body=body)
except ApiException as e:
    print("Exception when calling OidcrpApi->replaceOidcRp: %s\n" % e)

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

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

public class OidcrpApiExample {

    public static void main(String[] args) {
        
        OidcrpApi apiInstance = new OidcrpApi();
        confKey confKey = ; // confKey | Configuration key of OpenID Connect Relaying Party that needs to be updated
        OidcRpUpdate body = ; // OidcRpUpdate | 
        try {
            apiInstance.updateOidcRp(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OidcrpApi#updateOidcRp");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.OidcrpApi;

public class OidcrpApiExample {

    public static void main(String[] args) {
        OidcrpApi apiInstance = new OidcrpApi();
        confKey confKey = ; // confKey | Configuration key of OpenID Connect Relaying Party that needs to be updated
        OidcRpUpdate body = ; // OidcRpUpdate | 
        try {
            apiInstance.updateOidcRp(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OidcrpApi#updateOidcRp");
            e.printStackTrace();
        }
    }
}

confKey *confKey = ; // Configuration key of OpenID Connect Relaying Party that needs to be updated
OidcRpUpdate *body = ; //  (optional)

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

// Updates an OpenID Connect Relaying Party
[apiInstance updateOidcRpWith:confKey
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.OidcrpApi()
var confKey = ; // {{confKey}} Configuration key of OpenID Connect Relaying Party that needs to be updated
var opts = { 
  'body':  // {{OidcRpUpdate}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateOidcRp(confKey, opts, callback);

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

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

            var apiInstance = new OidcrpApi();
            var confKey = new confKey(); // confKey | Configuration key of OpenID Connect Relaying Party that needs to be updated
            var body = new OidcRpUpdate(); // OidcRpUpdate |  (optional) 

            try
            {
                // Updates an OpenID Connect Relaying Party
                apiInstance.updateOidcRp(confKey, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OidcrpApi.updateOidcRp: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiOidcrpApi();
$confKey = ; // confKey | Configuration key of OpenID Connect Relaying Party that needs to be updated
$body = ; // OidcRpUpdate | 

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

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

my $api_instance = WWW::SwaggerClient::OidcrpApi->new();
my $confKey = ; # confKey | Configuration key of OpenID Connect Relaying Party that needs to be updated
my $body = WWW::SwaggerClient::Object::OidcRpUpdate->new(); # OidcRpUpdate | 

eval { 
    $api_instance->updateOidcRp(confKey => $confKey, body => $body);
};
if ($@) {
    warn "Exception when calling OidcrpApi->updateOidcRp: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.OidcrpApi()
confKey =  # confKey | Configuration key of OpenID Connect Relaying Party that needs to be updated
body =  # OidcRpUpdate |  (optional)

try: 
    # Updates an OpenID Connect Relaying Party
    api_instance.update_oidc_rp(confKey, body=body)
except ApiException as e:
    print("Exception when calling OidcrpApi->updateOidcRp: %s\n" % e)

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

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

public class SamlspApiExample {

    public static void main(String[] args) {
        
        SamlspApi apiInstance = new SamlspApi();
        SamlSp body = ; // SamlSp | SAML Service provider to add
        try {
            apiInstance.addsamlsp(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamlspApi#addsamlsp");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SamlspApi;

public class SamlspApiExample {

    public static void main(String[] args) {
        SamlspApi apiInstance = new SamlspApi();
        SamlSp body = ; // SamlSp | SAML Service provider to add
        try {
            apiInstance.addsamlsp(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamlspApi#addsamlsp");
            e.printStackTrace();
        }
    }
}

SamlSp *body = ; // SAML Service provider to add

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

// Create a new SAML Service provider
[apiInstance addsamlspWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.SamlspApi()
var body = ; // {{SamlSp}} SAML Service provider to add

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

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

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

            var apiInstance = new SamlspApi();
            var body = new SamlSp(); // SamlSp | SAML Service provider to add

            try
            {
                // Create a new SAML Service provider
                apiInstance.addsamlsp(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SamlspApi.addsamlsp: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiSamlspApi();
$body = ; // SamlSp | SAML Service provider to add

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

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

my $api_instance = WWW::SwaggerClient::SamlspApi->new();
my $body = WWW::SwaggerClient::Object::SamlSp->new(); # SamlSp | SAML Service provider to add

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

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

# create an instance of the API class
api_instance = swagger_client.SamlspApi()
body =  # SamlSp | SAML Service provider to add

try: 
    # Create a new SAML Service provider
    api_instance.addsamlsp(body)
except ApiException as e:
    print("Exception when calling SamlspApi->addsamlsp: %s\n" % e)

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

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

public class SamlspApiExample {

    public static void main(String[] args) {
        
        SamlspApi apiInstance = new SamlspApi();
        confKey confKey = ; // confKey | Configuration key of SAML Service Provider to delete
        try {
            apiInstance.deleteSamlSp(confKey);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamlspApi#deleteSamlSp");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SamlspApi;

public class SamlspApiExample {

    public static void main(String[] args) {
        SamlspApi apiInstance = new SamlspApi();
        confKey confKey = ; // confKey | Configuration key of SAML Service Provider to delete
        try {
            apiInstance.deleteSamlSp(confKey);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamlspApi#deleteSamlSp");
            e.printStackTrace();
        }
    }
}

confKey *confKey = ; // Configuration key of SAML Service Provider to delete

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

// Deletes a SAML Service Provider
[apiInstance deleteSamlSpWith:confKey
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.SamlspApi()
var confKey = ; // {{confKey}} Configuration key of SAML Service Provider to delete

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

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

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

            var apiInstance = new SamlspApi();
            var confKey = new confKey(); // confKey | Configuration key of SAML Service Provider to delete

            try
            {
                // Deletes a SAML Service Provider
                apiInstance.deleteSamlSp(confKey);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SamlspApi.deleteSamlSp: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiSamlspApi();
$confKey = ; // confKey | Configuration key of SAML Service Provider to delete

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

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

my $api_instance = WWW::SwaggerClient::SamlspApi->new();
my $confKey = ; # confKey | Configuration key of SAML Service Provider to delete

eval { 
    $api_instance->deleteSamlSp(confKey => $confKey);
};
if ($@) {
    warn "Exception when calling SamlspApi->deleteSamlSp: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.SamlspApi()
confKey =  # confKey | Configuration key of SAML Service Provider to delete

try: 
    # Deletes a SAML Service Provider
    api_instance.delete_saml_sp(confKey)
except ApiException as e:
    print("Exception when calling SamlspApi->deleteSamlSp: %s\n" % e)

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

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

public class SamlspApiExample {

    public static void main(String[] args) {
        
        SamlspApi apiInstance = new SamlspApi();
        String pattern = pattern_example; // String | Search pattern
        try {
            array[SamlSp] result = apiInstance.findSamlSpByConfKey(pattern);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamlspApi#findSamlSpByConfKey");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SamlspApi;

public class SamlspApiExample {

    public static void main(String[] args) {
        SamlspApi apiInstance = new SamlspApi();
        String pattern = pattern_example; // String | Search pattern
        try {
            array[SamlSp] result = apiInstance.findSamlSpByConfKey(pattern);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamlspApi#findSamlSpByConfKey");
            e.printStackTrace();
        }
    }
}

String *pattern = pattern_example; // Search pattern

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

// Finds SAML Service providers by configuration key
[apiInstance findSamlSpByConfKeyWith:pattern
              completionHandler: ^(array[SamlSp] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.SamlspApi()
var pattern = pattern_example; // {{String}} Search pattern

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

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

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

            var apiInstance = new SamlspApi();
            var pattern = pattern_example;  // String | Search pattern

            try
            {
                // Finds SAML Service providers by configuration key
                array[SamlSp] result = apiInstance.findSamlSpByConfKey(pattern);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SamlspApi.findSamlSpByConfKey: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiSamlspApi();
$pattern = pattern_example; // String | Search pattern

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

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

my $api_instance = WWW::SwaggerClient::SamlspApi->new();
my $pattern = pattern_example; # String | Search pattern

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

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

# create an instance of the API class
api_instance = swagger_client.SamlspApi()
pattern = pattern_example # String | Search pattern

try: 
    # Finds SAML Service providers by configuration key
    api_response = api_instance.find_saml_sp_by_conf_key(pattern)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SamlspApi->findSamlSpByConfKey: %s\n" % e)

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

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

public class SamlspApiExample {

    public static void main(String[] args) {
        
        SamlspApi apiInstance = new SamlspApi();
        String entityId = entityId_example; // String | Entity ID to search
        try {
            SamlSp result = apiInstance.findSamlSpByEntityId(entityId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamlspApi#findSamlSpByEntityId");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SamlspApi;

public class SamlspApiExample {

    public static void main(String[] args) {
        SamlspApi apiInstance = new SamlspApi();
        String entityId = entityId_example; // String | Entity ID to search
        try {
            SamlSp result = apiInstance.findSamlSpByEntityId(entityId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamlspApi#findSamlSpByEntityId");
            e.printStackTrace();
        }
    }
}

String *entityId = entityId_example; // Entity ID to search

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

// Finds SAML Service Provider by Entity ID
[apiInstance findSamlSpByEntityIdWith:entityId
              completionHandler: ^(SamlSp output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.SamlspApi()
var entityId = entityId_example; // {{String}} Entity ID to search

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

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

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

            var apiInstance = new SamlspApi();
            var entityId = entityId_example;  // String | Entity ID to search

            try
            {
                // Finds SAML Service Provider by Entity ID
                SamlSp result = apiInstance.findSamlSpByEntityId(entityId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SamlspApi.findSamlSpByEntityId: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiSamlspApi();
$entityId = entityId_example; // String | Entity ID to search

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

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

my $api_instance = WWW::SwaggerClient::SamlspApi->new();
my $entityId = entityId_example; # String | Entity ID to search

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

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

# create an instance of the API class
api_instance = swagger_client.SamlspApi()
entityId = entityId_example # String | Entity ID to search

try: 
    # Finds SAML Service Provider by Entity ID
    api_response = api_instance.find_saml_sp_by_entity_id(entityId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SamlspApi->findSamlSpByEntityId: %s\n" % e)

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

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

public class SamlspApiExample {

    public static void main(String[] args) {
        
        SamlspApi apiInstance = new SamlspApi();
        confKey confKey = ; // confKey | Configuration key of SAML Service Provider
        try {
            SamlSp result = apiInstance.getSamlSpByConfKey(confKey);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamlspApi#getSamlSpByConfKey");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SamlspApi;

public class SamlspApiExample {

    public static void main(String[] args) {
        SamlspApi apiInstance = new SamlspApi();
        confKey confKey = ; // confKey | Configuration key of SAML Service Provider
        try {
            SamlSp result = apiInstance.getSamlSpByConfKey(confKey);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamlspApi#getSamlSpByConfKey");
            e.printStackTrace();
        }
    }
}

confKey *confKey = ; // Configuration key of SAML Service Provider

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

// Get SAML Service Provider by configuration key
[apiInstance getSamlSpByConfKeyWith:confKey
              completionHandler: ^(SamlSp output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.SamlspApi()
var confKey = ; // {{confKey}} Configuration key of SAML Service Provider

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

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

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

            var apiInstance = new SamlspApi();
            var confKey = new confKey(); // confKey | Configuration key of SAML Service Provider

            try
            {
                // Get SAML Service Provider by configuration key
                SamlSp result = apiInstance.getSamlSpByConfKey(confKey);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SamlspApi.getSamlSpByConfKey: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiSamlspApi();
$confKey = ; // confKey | Configuration key of SAML Service Provider

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

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

my $api_instance = WWW::SwaggerClient::SamlspApi->new();
my $confKey = ; # confKey | Configuration key of SAML Service Provider

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

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

# create an instance of the API class
api_instance = swagger_client.SamlspApi()
confKey =  # confKey | Configuration key of SAML Service Provider

try: 
    # Get SAML Service Provider by configuration key
    api_response = api_instance.get_saml_sp_by_conf_key(confKey)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SamlspApi->getSamlSpByConfKey: %s\n" % e)

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

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

public class SamlspApiExample {

    public static void main(String[] args) {
        
        SamlspApi apiInstance = new SamlspApi();
        confKey confKey = ; // confKey | Configuration key of SAML Service Provider that needs to be replaced
        SamlSpReplace body = ; // SamlSpReplace | 
        try {
            apiInstance.replaceSamlSp(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamlspApi#replaceSamlSp");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SamlspApi;

public class SamlspApiExample {

    public static void main(String[] args) {
        SamlspApi apiInstance = new SamlspApi();
        confKey confKey = ; // confKey | Configuration key of SAML Service Provider that needs to be replaced
        SamlSpReplace body = ; // SamlSpReplace | 
        try {
            apiInstance.replaceSamlSp(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamlspApi#replaceSamlSp");
            e.printStackTrace();
        }
    }
}

confKey *confKey = ; // Configuration key of SAML Service Provider that needs to be replaced
SamlSpReplace *body = ; //  (optional)

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

// Replaces a SAML Service
[apiInstance replaceSamlSpWith:confKey
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.SamlspApi()
var confKey = ; // {{confKey}} Configuration key of SAML Service Provider that needs to be replaced
var opts = { 
  'body':  // {{SamlSpReplace}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.replaceSamlSp(confKey, opts, callback);

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

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

            var apiInstance = new SamlspApi();
            var confKey = new confKey(); // confKey | Configuration key of SAML Service Provider that needs to be replaced
            var body = new SamlSpReplace(); // SamlSpReplace |  (optional) 

            try
            {
                // Replaces a SAML Service
                apiInstance.replaceSamlSp(confKey, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SamlspApi.replaceSamlSp: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiSamlspApi();
$confKey = ; // confKey | Configuration key of SAML Service Provider that needs to be replaced
$body = ; // SamlSpReplace | 

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

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

my $api_instance = WWW::SwaggerClient::SamlspApi->new();
my $confKey = ; # confKey | Configuration key of SAML Service Provider that needs to be replaced
my $body = WWW::SwaggerClient::Object::SamlSpReplace->new(); # SamlSpReplace | 

eval { 
    $api_instance->replaceSamlSp(confKey => $confKey, body => $body);
};
if ($@) {
    warn "Exception when calling SamlspApi->replaceSamlSp: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.SamlspApi()
confKey =  # confKey | Configuration key of SAML Service Provider that needs to be replaced
body =  # SamlSpReplace |  (optional)

try: 
    # Replaces a SAML Service
    api_instance.replace_saml_sp(confKey, body=body)
except ApiException as e:
    print("Exception when calling SamlspApi->replaceSamlSp: %s\n" % e)

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

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

public class SamlspApiExample {

    public static void main(String[] args) {
        
        SamlspApi apiInstance = new SamlspApi();
        confKey confKey = ; // confKey | Configuration key of SAML Service Provider that needs to be updated
        SamlSpUpdate body = ; // SamlSpUpdate | 
        try {
            apiInstance.updateSamlSp(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamlspApi#updateSamlSp");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SamlspApi;

public class SamlspApiExample {

    public static void main(String[] args) {
        SamlspApi apiInstance = new SamlspApi();
        confKey confKey = ; // confKey | Configuration key of SAML Service Provider that needs to be updated
        SamlSpUpdate body = ; // SamlSpUpdate | 
        try {
            apiInstance.updateSamlSp(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamlspApi#updateSamlSp");
            e.printStackTrace();
        }
    }
}

confKey *confKey = ; // Configuration key of SAML Service Provider that needs to be updated
SamlSpUpdate *body = ; //  (optional)

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

// Updates a SAML Service.
[apiInstance updateSamlSpWith:confKey
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.SamlspApi()
var confKey = ; // {{confKey}} Configuration key of SAML Service Provider that needs to be updated
var opts = { 
  'body':  // {{SamlSpUpdate}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateSamlSp(confKey, opts, callback);

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

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

            var apiInstance = new SamlspApi();
            var confKey = new confKey(); // confKey | Configuration key of SAML Service Provider that needs to be updated
            var body = new SamlSpUpdate(); // SamlSpUpdate |  (optional) 

            try
            {
                // Updates a SAML Service.
                apiInstance.updateSamlSp(confKey, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SamlspApi.updateSamlSp: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiSamlspApi();
$confKey = ; // confKey | Configuration key of SAML Service Provider that needs to be updated
$body = ; // SamlSpUpdate | 

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

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

my $api_instance = WWW::SwaggerClient::SamlspApi->new();
my $confKey = ; # confKey | Configuration key of SAML Service Provider that needs to be updated
my $body = WWW::SwaggerClient::Object::SamlSpUpdate->new(); # SamlSpUpdate | 

eval { 
    $api_instance->updateSamlSp(confKey => $confKey, body => $body);
};
if ($@) {
    warn "Exception when calling SamlspApi->updateSamlSp: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.SamlspApi()
confKey =  # confKey | Configuration key of SAML Service Provider that needs to be updated
body =  # SamlSpUpdate |  (optional)

try: 
    # Updates a SAML Service.
    api_instance.update_saml_sp(confKey, body=body)
except ApiException as e:
    print("Exception when calling SamlspApi->updateSamlSp: %s\n" % e)