# LemonLDAP::NG Manager API

## API and SDK Documentation

Version: 2.0.9

The Manager API allows an administrator to modify the LemonLDAP::NG configuration programmatically. It is not meant to be accessed by end users. The client libraries mentionned in examples can be generated from doc/sources/manager-api/openapi-spec.yaml

# Casapp

# addcasapp

Create a new CAS Application

    /api/v1/providers/cas/app

### Usage and SDK Samples

    curl -X POST "https://manager-api.example.com/api/v1/providers/cas/app"

    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)

## Parameters

Body parameters

Name | Description
--- | ---
body * |

## Responses

### Status: 201 - Successful creation

### Status: 400 - An error was encountered when processing the request

### Status: 409 - The specified object could not be created because its configuration key, client_id or entityID already exists

# deleteCasApp

Deletes a CAS Application

    /api/v1/providers/cas/app/{confKey}

### Usage and SDK Samples

    curl -X DELETE "https://manager-api.example.com/api/v1/providers/cas/app/{confKey}"

    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)

## Parameters

Path parameters

Name | Description
--- | ---
confKey* | confKey Configuration key of CAS Application to delete Required

## Responses

### Status: 204 - Successful modification

### Status: 400 - An error was encountered when processing the request

### Status: 404 - The specified resource was not found

# findCasAppByConfKey

Finds CAS applications by configuration key

Takes a search pattern to be tested against existing applications

    /api/v1/providers/cas/app/findByConfKey

### Usage and SDK Samples

    curl -X GET "https://manager-api.example.com/api/v1/providers/cas/app/findByConfKey?pattern="

    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)

## Parameters

Query parameters

Name | Description
--- | ---
pattern* | String Search pattern Required

## Responses

### Status: 200 - Return a list of CAS Providers

### Status: 400 - An error was encountered when processing the request

# findCasAppByServiceUrl

Get CAS Application by Service URL

    /api/v1/providers/cas/app/findByServiceUrl

### Usage and SDK Samples

    curl -X GET "https://manager-api.example.com/api/v1/providers/cas/app/findByServiceUrl?serviceUrl="

    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)

## Parameters

Query parameters

Name | Description
--- | ---
serviceUrl* | String Service URL to search Required

## Responses

### Status: 200 - Return a CAS Provider

### Status: 400 - An error was encountered when processing the request

### Status: 404 - The specified resource was not found

# getCasAppByConfKey

Get CAS Application by configuration key

Returns a single Application

    /api/v1/providers/cas/app/{confKey}

### Usage and SDK Samples

    curl -X GET "https://manager-api.example.com/api/v1/providers/cas/app/{confKey}"

    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)

## Parameters

Path parameters

Name | Description
--- | ---
confKey* | confKey Configuration key of CAS Application Required

## Responses

### Status: 200 - Return a CAS Provider

### Status: 400 - An error was encountered when processing the request

### Status: 404 - The specified resource was not found

# replaceCasApp

Replaces a CAS Application

    /api/v1/providers/cas/app/{confKey}

### Usage and SDK Samples

    curl -X PUT "https://manager-api.example.com/api/v1/providers/cas/app/{confKey}"

    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)

## Parameters

Path parameters

Name | Description
--- | ---
confKey* | confKey Configuration key of CAS Application that needs to be replaced Required

Body parameters

Name | Description
--- | ---
body |

## Responses

### Status: 204 - Successful modification

### Status: 400 - An error was encountered when processing the request

### Status: 404 - The specified resource was not found

### Status: 409 - The specified object could not be created because its configuration key, client_id or entityID already exists

# updateCasApp

Updates a CAS Application.

    /api/v1/providers/cas/app/{confKey}

### Usage and SDK Samples

    curl -X PATCH "https://manager-api.example.com/api/v1/providers/cas/app/{confKey}"

    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)

## Parameters

Path parameters

Name | Description
--- | ---
confKey* | confKey Configuration key of CAS Application that needs to be updated Required

Body parameters

Name | Description
--- | ---
body |

## Responses

### Status: 204 - Successful modification

### Status: 400 - An error was encountered when processing the request

### Status: 404 - The specified resource was not found

### Status: 409 - The specified object could not be created because its configuration key, client_id or entityID already exists

# Class2fa

# deleteSecondFactors

Delete all second factors for a user

    /api/v1/secondFactor/{uid}

### Usage and SDK Samples

    curl -X DELETE "https://manager-api.example.com/api/v1/secondFactor/{uid}"

    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)

## Parameters

Path parameters

Name | Description
--- | ---
uid* | String Required

## Responses

### Status: 204 - Successful modification

### Status: 404 - The specified resource was not found

# deleteSecondFactorsById

Delete a second factors for a user

    /api/v1/secondFactor/{uid}/id/{id}

### Usage and SDK Samples

    curl -X DELETE "https://manager-api.example.com/api/v1/secondFactor/{uid}/id/{id}"

    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)

## Parameters

Path parameters

Name | Description
--- | ---
uid* | String Required
id* | String Required

## Responses

### Status: 204 - Successful modification

### Status: 404 - The specified resource was not found

# deleteSecondFactorsByType

Delete all second factors of a given type for a user

    /api/v1/secondFactor/{uid}/type/{type}

### Usage and SDK Samples

    curl -X DELETE "https://manager-api.example.com/api/v1/secondFactor/{uid}/type/{type}"

    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)

## Parameters

Path parameters

Name | Description
--- | ---
uid* | String Required
type* | String Required

## Responses

### Status: 204 - Successful modification

### Status: 404 - The specified resource was not found

# getSecondFactors

List second factors for a user

    /api/v1/secondFactor/{uid}

### Usage and SDK Samples

    curl -X GET "https://manager-api.example.com/api/v1/secondFactor/{uid}"

    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)

## Parameters

Path parameters

Name | Description
--- | ---
uid* | String Required

## Responses

### Status: 200 - Return a list of second factors

### Status: 404 - The specified resource was not found

# getSecondFactorsById

Get second factors for a user given its ID

    /api/v1/secondFactor/{uid}/id/{id}

### Usage and SDK Samples

    curl -X GET "https://manager-api.example.com/api/v1/secondFactor/{uid}/id/{id}"

    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)

## Parameters

Path parameters

Name | Description
--- | ---
uid* | String Required
id* | String Required

## Responses

### Status: 200 - Return a list of second factors

### Status: 404 - The specified resource was not found

# getSecondFactorsByType

List second factors for a user given its type

    /api/v1/secondFactor/{uid}/type/{type}

### Usage and SDK Samples

    curl -X GET "https://manager-api.example.com/api/v1/secondFactor/{uid}/type/{type}"

    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)

## Parameters

Path parameters

Name | Description
--- | ---
uid* | String Required
type* | String Required

## Responses

### Status: 200 - Return a list of second factors

### Status: 404 - The specified resource was not found

# Default

# status

Check the status of the API

    /api/v1/status

### Usage and SDK Samples

    curl -X GET "https://manager-api.example.com/api/v1/status"

    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)

## Parameters

## Responses

### Status: 200 - Response to API health check

### Status: 503 - Response to API health check

# Menuapp

# addMenuApp

Create a new Menu Application within a Menu Category

    /api/v1/menu/app/{cat}

### Usage and SDK Samples

    curl -X POST "https://manager-api.example.com/api/v1/menu/app/{cat}"

    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)

## Parameters

Path parameters

Name | Description
--- | ---
cat* | menuCatConfKey Configuration key of Menu Category to work with Required

Body parameters

Name | Description
--- | ---
body * |

## Responses

### Status: 201 - Successful creation

### Status: 400 - An error was encountered when processing the request

### Status: 404 - The specified resource was not found

### Status: 409 - The specified object could not be created because its configuration key, client_id or entityID already exists

# deleteMenuApp

Deletes a Menu Application

    /api/v1/menu/app/{cat}/{confKey}

### Usage and SDK Samples

    curl -X DELETE "https://manager-api.example.com/api/v1/menu/app/{cat}/{confKey}"

    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)

## Parameters

Path parameters

Name | Description
--- | ---
cat* | menuCatConfKey Configuration key of Menu Category to work with Required
confKey* | confKey Configuration key of Menu Application to delete Required

## Responses

### Status: 204 - Successful modification

### Status: 400 - An error was encountered when processing the request

### Status: 404 - The specified resource was not found

# findMenuAppByConfKey

Finds Menu Applications by configuration key within a Menu Category

Takes a search pattern to be tested against existing applications within a menu category

    /api/v1/menu/app/{cat}/findByConfKey

### Usage and SDK Samples

    curl -X GET "https://manager-api.example.com/api/v1/menu/app/{cat}/findByConfKey?pattern="

    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)

## Parameters

Path parameters

Name | Description
--- | ---
cat* | menuCatConfKey Configuration key of Menu Category to work with Required

Query parameters

Name | Description
--- | ---
pattern* | String Search pattern Required

## Responses

### Status: 200 - Return a list of Menu Applications

### Status: 400 - An error was encountered when processing the request

# getMenuAppByConfKey

Get Menu Application within a Menu Category by configuration key

Returns a single application

    /api/v1/menu/app/{cat}/{confKey}

### Usage and SDK Samples

    curl -X GET "https://manager-api.example.com/api/v1/menu/app/{cat}/{confKey}"

    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)

## Parameters

Path parameters

Name | Description
--- | ---
cat* | menuCatConfKey Configuration key of Menu Category to work with Required
confKey* | confKey Configuration key of Menu Application Required

## Responses

### Status: 200 - Return a Menu Application

### Status: 400 - An error was encountered when processing the request

### Status: 404 - The specified resource was not found

# getMenuApps

Get Menu Applications within a Menu Category

Return existing applications within a menu category

    /api/v1/menu/app/{cat}

### Usage and SDK Samples

    curl -X GET "https://manager-api.example.com/api/v1/menu/app/{cat}"

    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)

## Parameters

Path parameters

Name | Description
--- | ---
cat* | menuCatConfKey Configuration key of Menu Category to work with Required

## Responses

### Status: 200 - Return a list of Menu Applications

### Status: 400 - An error was encountered when processing the request

### Status: 404 - The specified resource was not found

# replaceMenuApp

Replaces a Menu Application

    /api/v1/menu/app/{cat}/{confKey}

### Usage and SDK Samples

    curl -X PUT "https://manager-api.example.com/api/v1/menu/app/{cat}/{confKey}"

    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)

## Parameters

Path parameters

Name | Description
--- | ---
cat* | menuCatConfKey Configuration key of Menu Category to work with Required
confKey* | confKey Configuration key of Menu Application that needs to be replaced Required

Body parameters

Name | Description
--- | ---
body |

## Responses

### Status: 204 - Successful modification

### Status: 400 - An error was encountered when processing the request

### Status: 404 - The specified resource was not found

### Status: 409 - The specified object could not be created because its configuration key, client_id or entityID already exists

# updateMenuApp

Updates a Menu Application

    /api/v1/menu/app/{cat}/{confKey}

### Usage and SDK Samples

    curl -X PATCH "https://manager-api.example.com/api/v1/menu/app/{cat}/{confKey}"

    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)

## Parameters

Path parameters

Name | Description
--- | ---
cat* | menuCatConfKey Configuration key of Menu Category to work with Required
confKey* | confKey Configuration key of Menu Application that needs to be updated Required

Body parameters

Name | Description
--- | ---
body |

## Responses

### Status: 204 - Successful modification

### Status: 400 - An error was encountered when processing the request

### Status: 404 - The specified resource was not found

### Status: 409 - The specified object could not be created because its configuration key, client_id or entityID already exists

# Menucat

# addMenuCat

Create a new Menu Category

    /api/v1/menu/cat

### Usage and SDK Samples

    curl -X POST "https://manager-api.example.com/api/v1/menu/cat"

    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)

## Parameters

Body parameters

Name | Description
--- | ---
body * |

## Responses

### Status: 201 - Successful creation

### Status: 400 - An error was encountered when processing the request

### Status: 409 - The specified object could not be created because its configuration key, client_id or entityID already exists

# deleteMenuCat

Deletes a Menu Category

    /api/v1/menu/cat/{confKey}

### Usage and SDK Samples

    curl -X DELETE "https://manager-api.example.com/api/v1/menu/cat/{confKey}"

    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)

## Parameters

Path parameters

Name | Description
--- | ---
confKey* | confKey Configuration key of Menu Category to delete Required

## Responses

### Status: 204 - Successful modification

### Status: 400 - An error was encountered when processing the request

### Status: 404 - The specified resource was not found

# findMenuCatByConfKey

Finds Menu Categories by configuration key

Takes a search pattern to be tested against existing categories

    /api/v1/menu/cat/findByConfKey

### Usage and SDK Samples

    curl -X GET "https://manager-api.example.com/api/v1/menu/cat/findByConfKey?pattern="

    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)

## Parameters

Query parameters

Name | Description
--- | ---
pattern* | String Search pattern Required

## Responses

### Status: 200 - Return a list of Menu Categories

### Status: 400 - An error was encountered when processing the request

# getMenuCatByConfKey

Get Menu Category by configuration key

Returns a single Category

    /api/v1/menu/cat/{confKey}

### Usage and SDK Samples

    curl -X GET "https://manager-api.example.com/api/v1/menu/cat/{confKey}"

    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)

## Parameters

Path parameters

Name | Description
--- | ---
confKey* | confKey Configuration key of Menu Category Required

## Responses

### Status: 200 - Return a Menu Category

### Status: 400 - An error was encountered when processing the request

### Status: 404 - The specified resource was not found

# replaceMenuCat

Replaces a Menu Category

    /api/v1/menu/cat/{confKey}

### Usage and SDK Samples

    curl -X PUT "https://manager-api.example.com/api/v1/menu/cat/{confKey}"

    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)

## Parameters

Path parameters

Name | Description
--- | ---
confKey* | confKey Configuration key of Menu Category that needs to be replaced Required

Body parameters

Name | Description
--- | ---
body |

## Responses

### Status: 204 - Successful modification

### Status: 400 - An error was encountered when processing the request

### Status: 404 - The specified resource was not found

### Status: 409 - The specified object could not be created because its configuration key, client_id or entityID already exists

# updateMenuCat

Updates a Menu Category

    /api/v1/menu/cat/{confKey}

### Usage and SDK Samples

    curl -X PATCH "https://manager-api.example.com/api/v1/menu/cat/{confKey}"

    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)

## Parameters

Path parameters

Name | Description
--- | ---
confKey* | confKey Configuration key of Menu Category that needs to be updated Required

Body parameters

Name | Description
--- | ---
body |

## Responses

### Status: 204 - Successful modification

### Status: 400 - An error was encountered when processing the request

### Status: 404 - The specified resource was not found

### Status: 409 - The specified object could not be created because its configuration key, client_id or entityID already exists

# Oidcrp

# addoidcrp

Create a new OpenID Connect Relaying Party

    /api/v1/providers/oidc/rp

### Usage and SDK Samples

    curl -X POST "https://manager-api.example.com/api/v1/providers/oidc/rp"

    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)

## Parameters

Body parameters

Name | Description
--- | ---
body * |

## Responses

### Status: 201 - Successful creation

### Status: 400 - An error was encountered when processing the request

### Status: 409 - The specified object could not be created because its configuration key, client_id or entityID already exists

# deleteOidcRp

Deletes a OpenID Connect Relaying Party

    /api/v1/providers/oidc/rp/{confKey}

### Usage and SDK Samples

    curl -X DELETE "https://manager-api.example.com/api/v1/providers/oidc/rp/{confKey}"

    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)

## Parameters

Path parameters

Name | Description
--- | ---
confKey* | confKey Configuration key of OpenID Connect Relaying Party to delete Required

## Responses

### Status: 204 - Successful modification

### Status: 400 - An error was encountered when processing the request

### Status: 404 - The specified resource was not found

# findOidcRpByClientId

Finds OpenID Connect Relaying Party by Client ID

    /api/v1/providers/oidc/rp/findByClientId

### Usage and SDK Samples

    curl -X GET "https://manager-api.example.com/api/v1/providers/oidc/rp/findByClientId?clientId="

    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)

## Parameters

Query parameters

Name | Description
--- | ---
clientId* | String Client ID to search Required

## Responses

### Status: 200 - Return an OpenID Connect Provider

### Status: 400 - An error was encountered when processing the request

### Status: 404 - The specified resource was not found

# findOidcRpByConfKey

Finds OpenID Connect Relaying Partys by configuration key

Takes a search pattern to be tested against existing service providers

    /api/v1/providers/oidc/rp/findByConfKey

### Usage and SDK Samples

    curl -X GET "https://manager-api.example.com/api/v1/providers/oidc/rp/findByConfKey?pattern="

    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)

## Parameters

Query parameters

Name | Description
--- | ---
pattern* | confKey Search pattern Required

## Responses

### Status: 200 - Return a list of OpenID Connect Providers

### Status: 400 - An error was encountered when processing the request

# getOidcRpByConfKey

Get OpenID Connect Relaying Party by configuration key

Returns a single Service Provider

    /api/v1/providers/oidc/rp/{confKey}

### Usage and SDK Samples

    curl -X GET "https://manager-api.example.com/api/v1/providers/oidc/rp/{confKey}"

    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)

## Parameters

Path parameters

Name | Description
--- | ---
confKey* | confKey Configuration key of OpenID Connect Relaying Party Required

## Responses

### Status: 200 - Return an OpenID Connect Provider

### Status: 400 - An error was encountered when processing the request

### Status: 404 - The specified resource was not found

# replaceOidcRp

Replaces an OpenID Connect Relaying Party

    /api/v1/providers/oidc/rp/{confKey}

### Usage and SDK Samples

    curl -X PUT "https://manager-api.example.com/api/v1/providers/oidc/rp/{confKey}"

    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)

## Parameters

Path parameters

Name | Description
--- | ---
confKey* | confKey Configuration key of OpenID Connect Relaying Party that needs to be replaced Required

Body parameters

Name | Description
--- | ---
body |

## Responses

### Status: 204 - Successful modification

### Status: 400 - An error was encountered when processing the request

### Status: 404 - The specified resource was not found

### Status: 409 - The specified object could not be created because its configuration key, client_id or entityID already exists

# updateOidcRp

Updates an OpenID Connect Relaying Party

    /api/v1/providers/oidc/rp/{confKey}

### Usage and SDK Samples

    curl -X PATCH "https://manager-api.example.com/api/v1/providers/oidc/rp/{confKey}"

    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)

## Parameters

Path parameters

Name | Description
--- | ---
confKey* | confKey Configuration key of OpenID Connect Relaying Party that needs to be updated Required

Body parameters

Name | Description
--- | ---
body |

## Responses

### Status: 204 - Successful modification

### Status: 400 - An error was encountered when processing the request

### Status: 404 - The specified resource was not found

### Status: 409 - The specified object could not be created because its configuration key, client_id or entityID already exists

# Samlsp

# addsamlsp

Create a new SAML Service provider

    /api/v1/providers/saml/sp

### Usage and SDK Samples

    curl -X POST "https://manager-api.example.com/api/v1/providers/saml/sp"

    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)

## Parameters

Body parameters

Name | Description
--- | ---
body * |

## Responses

### Status: 201 - Successful creation

### Status: 400 - An error was encountered when processing the request

### Status: 409 - The specified object could not be created because its configuration key, client_id or entityID already exists

# deleteSamlSp

Deletes a SAML Service Provider

    /api/v1/providers/saml/sp/{confKey}

### Usage and SDK Samples

    curl -X DELETE "https://manager-api.example.com/api/v1/providers/saml/sp/{confKey}"

    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)

## Parameters

Path parameters

Name | Description
--- | ---
confKey* | confKey Configuration key of SAML Service Provider to delete Required

## Responses

### Status: 204 - Successful modification

### Status: 400 - An error was encountered when processing the request

### Status: 404 - The specified resource was not found

# findSamlSpByConfKey

Finds SAML Service providers by configuration key

Takes a search pattern to be tested against existing service providers

    /api/v1/providers/saml/sp/findByConfKey

### Usage and SDK Samples

    curl -X GET "https://manager-api.example.com/api/v1/providers/saml/sp/findByConfKey?pattern="

    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)

## Parameters

Query parameters

Name | Description
--- | ---
pattern* | String Search pattern Required

## Responses

### Status: 200 - Return a list of SAML Providers

### Status: 400 - An error was encountered when processing the request

# findSamlSpByEntityId

Finds SAML Service Provider by Entity ID

    /api/v1/providers/saml/sp/findByEntityId

### Usage and SDK Samples

    curl -X GET "https://manager-api.example.com/api/v1/providers/saml/sp/findByEntityId?entityId="

    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)

## Parameters

Query parameters

Name | Description
--- | ---
entityId* | String Entity ID to search Required

## Responses

### Status: 200 - Return a SAML Provider

### Status: 400 - An error was encountered when processing the request

### Status: 404 - The specified resource was not found

# getSamlSpByConfKey

Get SAML Service Provider by configuration key

Returns a single Service Provider

    /api/v1/providers/saml/sp/{confKey}

### Usage and SDK Samples

    curl -X GET "https://manager-api.example.com/api/v1/providers/saml/sp/{confKey}"

    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)

## Parameters

Path parameters

Name | Description
--- | ---
confKey* | confKey Configuration key of SAML Service Provider Required

## Responses

### Status: 200 - Return a SAML Provider

### Status: 400 - An error was encountered when processing the request

### Status: 404 - The specified resource was not found

# replaceSamlSp

Replaces a SAML Service

    /api/v1/providers/saml/sp/{confKey}

### Usage and SDK Samples

    curl -X PUT "https://manager-api.example.com/api/v1/providers/saml/sp/{confKey}"

    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)

## Parameters

Path parameters

Name | Description
--- | ---
confKey* | confKey Configuration key of SAML Service Provider that needs to be replaced Required

Body parameters

Name | Description
--- | ---
body |

## Responses

### Status: 204 - Successful modification

### Status: 400 - An error was encountered when processing the request

### Status: 404 - The specified resource was not found

### Status: 409 - The specified object could not be created because its configuration key, client_id or entityID already exists

# updateSamlSp

Updates a SAML Service.

    /api/v1/providers/saml/sp/{confKey}

### Usage and SDK Samples

    curl -X PATCH "https://manager-api.example.com/api/v1/providers/saml/sp/{confKey}"

    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)

## Parameters

Path parameters

Name | Description
--- | ---
confKey* | confKey Configuration key of SAML Service Provider that needs to be updated Required

Body parameters

Name | Description
--- | ---
body |

## Responses

### Status: 204 - Successful modification

### Status: 400 - An error was encountered when processing the request

### Status: 404 - The specified resource was not found

### Status: 409 - The specified object could not be created because its configuration key, client_id or entityID already exists