import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AuthtokenApi;

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

public class AuthtokenApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AuthtokenApi apiInstance = new AuthtokenApi();
        String xOkapiTenant = xOkapiTenant_example; // String | Okapi Tenant
        String xOkapiUrl = xOkapiUrl_example; // String | Okapi URL
        RefreshToken refreshToken = ; // RefreshToken | 

        try {
            apiInstance.tokenInvalidate(xOkapiTenant, xOkapiUrl, refreshToken);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthtokenApi#tokenInvalidate");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String xOkapiTenant = new String(); // String | Okapi Tenant
final String xOkapiUrl = new String(); // String | Okapi URL
final RefreshToken refreshToken = new RefreshToken(); // RefreshToken | 

try {
    final result = await api_instance.tokenInvalidate(xOkapiTenant, xOkapiUrl, refreshToken);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->tokenInvalidate: $e\n');
}

import org.openapitools.client.api.AuthtokenApi;

public class AuthtokenApiExample {
    public static void main(String[] args) {
        AuthtokenApi apiInstance = new AuthtokenApi();
        String xOkapiTenant = xOkapiTenant_example; // String | Okapi Tenant
        String xOkapiUrl = xOkapiUrl_example; // String | Okapi URL
        RefreshToken refreshToken = ; // RefreshToken | 

        try {
            apiInstance.tokenInvalidate(xOkapiTenant, xOkapiUrl, refreshToken);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthtokenApi#tokenInvalidate");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AuthtokenApi *apiInstance = [[AuthtokenApi alloc] init];
String *xOkapiTenant = xOkapiTenant_example; // Okapi Tenant (default to null)
String *xOkapiUrl = xOkapiUrl_example; // Okapi URL (default to null)
RefreshToken *refreshToken = ; // 

[apiInstance tokenInvalidateWith:xOkapiTenant
    xOkapiUrl:xOkapiUrl
    refreshToken:refreshToken
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ModLoginKeycloakApi = require('mod_login_keycloak_api');

// Create an instance of the API class
var api = new ModLoginKeycloakApi.AuthtokenApi()
var xOkapiTenant = xOkapiTenant_example; // {String} Okapi Tenant
var xOkapiUrl = xOkapiUrl_example; // {String} Okapi URL
var refreshToken = ; // {RefreshToken} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AuthtokenApi();
            var xOkapiTenant = xOkapiTenant_example;  // String | Okapi Tenant (default to null)
            var xOkapiUrl = xOkapiUrl_example;  // String | Okapi URL (default to null)
            var refreshToken = new RefreshToken(); // RefreshToken | 

            try {
                apiInstance.tokenInvalidate(xOkapiTenant, xOkapiUrl, refreshToken);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthtokenApi.tokenInvalidate: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthtokenApi();
$xOkapiTenant = xOkapiTenant_example; // String | Okapi Tenant
$xOkapiUrl = xOkapiUrl_example; // String | Okapi URL
$refreshToken = ; // RefreshToken | 

try {
    $api_instance->tokenInvalidate($xOkapiTenant, $xOkapiUrl, $refreshToken);
} catch (Exception $e) {
    echo 'Exception when calling AuthtokenApi->tokenInvalidate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AuthtokenApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthtokenApi->new();
my $xOkapiTenant = xOkapiTenant_example; # String | Okapi Tenant
my $xOkapiUrl = xOkapiUrl_example; # String | Okapi URL
my $refreshToken = WWW::OPenAPIClient::Object::RefreshToken->new(); # RefreshToken | 

eval {
    $api_instance->tokenInvalidate(xOkapiTenant => $xOkapiTenant, xOkapiUrl => $xOkapiUrl, refreshToken => $refreshToken);
};
if ($@) {
    warn "Exception when calling AuthtokenApi->tokenInvalidate: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.AuthtokenApi()
xOkapiTenant = xOkapiTenant_example # String | Okapi Tenant (default to null)
xOkapiUrl = xOkapiUrl_example # String | Okapi URL (default to null)
refreshToken =  # RefreshToken | 

try:
    api_instance.token_invalidate(xOkapiTenant, xOkapiUrl, refreshToken)
except ApiException as e:
    print("Exception when calling AuthtokenApi->tokenInvalidate: %s\n" % e)

extern crate AuthtokenApi;

pub fn main() {
    let xOkapiTenant = xOkapiTenant_example; // String
    let xOkapiUrl = xOkapiUrl_example; // String
    let refreshToken = ; // RefreshToken

    let mut context = AuthtokenApi::Context::default();
    let result = client.tokenInvalidate(xOkapiTenant, xOkapiUrl, refreshToken, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AuthtokenApi;

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

public class AuthtokenApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AuthtokenApi apiInstance = new AuthtokenApi();
        String xOkapiTenant = xOkapiTenant_example; // String | Okapi Tenant
        String xOkapiUrl = xOkapiUrl_example; // String | Okapi URL

        try {
            apiInstance.tokenInvalidateAll(xOkapiTenant, xOkapiUrl);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthtokenApi#tokenInvalidateAll");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String xOkapiTenant = new String(); // String | Okapi Tenant
final String xOkapiUrl = new String(); // String | Okapi URL

try {
    final result = await api_instance.tokenInvalidateAll(xOkapiTenant, xOkapiUrl);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->tokenInvalidateAll: $e\n');
}

import org.openapitools.client.api.AuthtokenApi;

public class AuthtokenApiExample {
    public static void main(String[] args) {
        AuthtokenApi apiInstance = new AuthtokenApi();
        String xOkapiTenant = xOkapiTenant_example; // String | Okapi Tenant
        String xOkapiUrl = xOkapiUrl_example; // String | Okapi URL

        try {
            apiInstance.tokenInvalidateAll(xOkapiTenant, xOkapiUrl);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthtokenApi#tokenInvalidateAll");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AuthtokenApi *apiInstance = [[AuthtokenApi alloc] init];
String *xOkapiTenant = xOkapiTenant_example; // Okapi Tenant (default to null)
String *xOkapiUrl = xOkapiUrl_example; // Okapi URL (default to null)

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

var ModLoginKeycloakApi = require('mod_login_keycloak_api');

// Create an instance of the API class
var api = new ModLoginKeycloakApi.AuthtokenApi()
var xOkapiTenant = xOkapiTenant_example; // {String} Okapi Tenant
var xOkapiUrl = xOkapiUrl_example; // {String} Okapi URL

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AuthtokenApi();
            var xOkapiTenant = xOkapiTenant_example;  // String | Okapi Tenant (default to null)
            var xOkapiUrl = xOkapiUrl_example;  // String | Okapi URL (default to null)

            try {
                apiInstance.tokenInvalidateAll(xOkapiTenant, xOkapiUrl);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthtokenApi.tokenInvalidateAll: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthtokenApi();
$xOkapiTenant = xOkapiTenant_example; // String | Okapi Tenant
$xOkapiUrl = xOkapiUrl_example; // String | Okapi URL

try {
    $api_instance->tokenInvalidateAll($xOkapiTenant, $xOkapiUrl);
} catch (Exception $e) {
    echo 'Exception when calling AuthtokenApi->tokenInvalidateAll: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AuthtokenApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthtokenApi->new();
my $xOkapiTenant = xOkapiTenant_example; # String | Okapi Tenant
my $xOkapiUrl = xOkapiUrl_example; # String | Okapi URL

eval {
    $api_instance->tokenInvalidateAll(xOkapiTenant => $xOkapiTenant, xOkapiUrl => $xOkapiUrl);
};
if ($@) {
    warn "Exception when calling AuthtokenApi->tokenInvalidateAll: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.AuthtokenApi()
xOkapiTenant = xOkapiTenant_example # String | Okapi Tenant (default to null)
xOkapiUrl = xOkapiUrl_example # String | Okapi URL (default to null)

try:
    api_instance.token_invalidate_all(xOkapiTenant, xOkapiUrl)
except ApiException as e:
    print("Exception when calling AuthtokenApi->tokenInvalidateAll: %s\n" % e)

extern crate AuthtokenApi;

pub fn main() {
    let xOkapiTenant = xOkapiTenant_example; // String
    let xOkapiUrl = xOkapiUrl_example; // String

    let mut context = AuthtokenApi::Context::default();
    let result = client.tokenInvalidateAll(xOkapiTenant, xOkapiUrl, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AuthtokenApi;

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

public class AuthtokenApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AuthtokenApi apiInstance = new AuthtokenApi();
        String xOkapiTenant = xOkapiTenant_example; // String | Okapi Tenant
        String xOkapiUrl = xOkapiUrl_example; // String | Okapi URL
        SignTokenPayload signTokenPayload = ; // SignTokenPayload | 

        try {
            tokenResponseLegacy result = apiInstance.tokenLegacy(xOkapiTenant, xOkapiUrl, signTokenPayload);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthtokenApi#tokenLegacy");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String xOkapiTenant = new String(); // String | Okapi Tenant
final String xOkapiUrl = new String(); // String | Okapi URL
final SignTokenPayload signTokenPayload = new SignTokenPayload(); // SignTokenPayload | 

try {
    final result = await api_instance.tokenLegacy(xOkapiTenant, xOkapiUrl, signTokenPayload);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->tokenLegacy: $e\n');
}

import org.openapitools.client.api.AuthtokenApi;

public class AuthtokenApiExample {
    public static void main(String[] args) {
        AuthtokenApi apiInstance = new AuthtokenApi();
        String xOkapiTenant = xOkapiTenant_example; // String | Okapi Tenant
        String xOkapiUrl = xOkapiUrl_example; // String | Okapi URL
        SignTokenPayload signTokenPayload = ; // SignTokenPayload | 

        try {
            tokenResponseLegacy result = apiInstance.tokenLegacy(xOkapiTenant, xOkapiUrl, signTokenPayload);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthtokenApi#tokenLegacy");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AuthtokenApi *apiInstance = [[AuthtokenApi alloc] init];
String *xOkapiTenant = xOkapiTenant_example; // Okapi Tenant (default to null)
String *xOkapiUrl = xOkapiUrl_example; // Okapi URL (default to null)
SignTokenPayload *signTokenPayload = ; //  (optional)

[apiInstance tokenLegacyWith:xOkapiTenant
    xOkapiUrl:xOkapiUrl
    signTokenPayload:signTokenPayload
              completionHandler: ^(tokenResponseLegacy output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ModLoginKeycloakApi = require('mod_login_keycloak_api');

// Create an instance of the API class
var api = new ModLoginKeycloakApi.AuthtokenApi()
var xOkapiTenant = xOkapiTenant_example; // {String} Okapi Tenant
var xOkapiUrl = xOkapiUrl_example; // {String} Okapi URL
var opts = {
  'signTokenPayload':  // {SignTokenPayload} 
};

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AuthtokenApi();
            var xOkapiTenant = xOkapiTenant_example;  // String | Okapi Tenant (default to null)
            var xOkapiUrl = xOkapiUrl_example;  // String | Okapi URL (default to null)
            var signTokenPayload = new SignTokenPayload(); // SignTokenPayload |  (optional) 

            try {
                tokenResponseLegacy result = apiInstance.tokenLegacy(xOkapiTenant, xOkapiUrl, signTokenPayload);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthtokenApi.tokenLegacy: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthtokenApi();
$xOkapiTenant = xOkapiTenant_example; // String | Okapi Tenant
$xOkapiUrl = xOkapiUrl_example; // String | Okapi URL
$signTokenPayload = ; // SignTokenPayload | 

try {
    $result = $api_instance->tokenLegacy($xOkapiTenant, $xOkapiUrl, $signTokenPayload);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthtokenApi->tokenLegacy: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AuthtokenApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthtokenApi->new();
my $xOkapiTenant = xOkapiTenant_example; # String | Okapi Tenant
my $xOkapiUrl = xOkapiUrl_example; # String | Okapi URL
my $signTokenPayload = WWW::OPenAPIClient::Object::SignTokenPayload->new(); # SignTokenPayload | 

eval {
    my $result = $api_instance->tokenLegacy(xOkapiTenant => $xOkapiTenant, xOkapiUrl => $xOkapiUrl, signTokenPayload => $signTokenPayload);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthtokenApi->tokenLegacy: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.AuthtokenApi()
xOkapiTenant = xOkapiTenant_example # String | Okapi Tenant (default to null)
xOkapiUrl = xOkapiUrl_example # String | Okapi URL (default to null)
signTokenPayload =  # SignTokenPayload |  (optional)

try:
    api_response = api_instance.token_legacy(xOkapiTenant, xOkapiUrl, signTokenPayload=signTokenPayload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthtokenApi->tokenLegacy: %s\n" % e)

extern crate AuthtokenApi;

pub fn main() {
    let xOkapiTenant = xOkapiTenant_example; // String
    let xOkapiUrl = xOkapiUrl_example; // String
    let signTokenPayload = ; // SignTokenPayload

    let mut context = AuthtokenApi::Context::default();
    let result = client.tokenLegacy(xOkapiTenant, xOkapiUrl, signTokenPayload, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AuthtokenApi;

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

public class AuthtokenApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AuthtokenApi apiInstance = new AuthtokenApi();
        String xOkapiTenant = xOkapiTenant_example; // String | Okapi Tenant
        String xOkapiUrl = xOkapiUrl_example; // String | Okapi URL
        RefreshToken refreshToken = ; // RefreshToken | 

        try {
            tokenResponse result = apiInstance.tokenRefresh(xOkapiTenant, xOkapiUrl, refreshToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthtokenApi#tokenRefresh");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String xOkapiTenant = new String(); // String | Okapi Tenant
final String xOkapiUrl = new String(); // String | Okapi URL
final RefreshToken refreshToken = new RefreshToken(); // RefreshToken | 

try {
    final result = await api_instance.tokenRefresh(xOkapiTenant, xOkapiUrl, refreshToken);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->tokenRefresh: $e\n');
}

import org.openapitools.client.api.AuthtokenApi;

public class AuthtokenApiExample {
    public static void main(String[] args) {
        AuthtokenApi apiInstance = new AuthtokenApi();
        String xOkapiTenant = xOkapiTenant_example; // String | Okapi Tenant
        String xOkapiUrl = xOkapiUrl_example; // String | Okapi URL
        RefreshToken refreshToken = ; // RefreshToken | 

        try {
            tokenResponse result = apiInstance.tokenRefresh(xOkapiTenant, xOkapiUrl, refreshToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthtokenApi#tokenRefresh");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AuthtokenApi *apiInstance = [[AuthtokenApi alloc] init];
String *xOkapiTenant = xOkapiTenant_example; // Okapi Tenant (default to null)
String *xOkapiUrl = xOkapiUrl_example; // Okapi URL (default to null)
RefreshToken *refreshToken = ; // 

[apiInstance tokenRefreshWith:xOkapiTenant
    xOkapiUrl:xOkapiUrl
    refreshToken:refreshToken
              completionHandler: ^(tokenResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ModLoginKeycloakApi = require('mod_login_keycloak_api');

// Create an instance of the API class
var api = new ModLoginKeycloakApi.AuthtokenApi()
var xOkapiTenant = xOkapiTenant_example; // {String} Okapi Tenant
var xOkapiUrl = xOkapiUrl_example; // {String} Okapi URL
var refreshToken = ; // {RefreshToken} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AuthtokenApi();
            var xOkapiTenant = xOkapiTenant_example;  // String | Okapi Tenant (default to null)
            var xOkapiUrl = xOkapiUrl_example;  // String | Okapi URL (default to null)
            var refreshToken = new RefreshToken(); // RefreshToken | 

            try {
                tokenResponse result = apiInstance.tokenRefresh(xOkapiTenant, xOkapiUrl, refreshToken);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthtokenApi.tokenRefresh: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthtokenApi();
$xOkapiTenant = xOkapiTenant_example; // String | Okapi Tenant
$xOkapiUrl = xOkapiUrl_example; // String | Okapi URL
$refreshToken = ; // RefreshToken | 

try {
    $result = $api_instance->tokenRefresh($xOkapiTenant, $xOkapiUrl, $refreshToken);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthtokenApi->tokenRefresh: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AuthtokenApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthtokenApi->new();
my $xOkapiTenant = xOkapiTenant_example; # String | Okapi Tenant
my $xOkapiUrl = xOkapiUrl_example; # String | Okapi URL
my $refreshToken = WWW::OPenAPIClient::Object::RefreshToken->new(); # RefreshToken | 

eval {
    my $result = $api_instance->tokenRefresh(xOkapiTenant => $xOkapiTenant, xOkapiUrl => $xOkapiUrl, refreshToken => $refreshToken);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthtokenApi->tokenRefresh: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.AuthtokenApi()
xOkapiTenant = xOkapiTenant_example # String | Okapi Tenant (default to null)
xOkapiUrl = xOkapiUrl_example # String | Okapi URL (default to null)
refreshToken =  # RefreshToken | 

try:
    api_response = api_instance.token_refresh(xOkapiTenant, xOkapiUrl, refreshToken)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthtokenApi->tokenRefresh: %s\n" % e)

extern crate AuthtokenApi;

pub fn main() {
    let xOkapiTenant = xOkapiTenant_example; // String
    let xOkapiUrl = xOkapiUrl_example; // String
    let refreshToken = ; // RefreshToken

    let mut context = AuthtokenApi::Context::default();
    let result = client.tokenRefresh(xOkapiTenant, xOkapiUrl, refreshToken, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AuthtokenApi;

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

public class AuthtokenApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AuthtokenApi apiInstance = new AuthtokenApi();
        String xOkapiTenant = xOkapiTenant_example; // String | Okapi Tenant
        String xOkapiUrl = xOkapiUrl_example; // String | Okapi URL
        SignTokenPayload signTokenPayload = ; // SignTokenPayload | 

        try {
            tokenResponse result = apiInstance.tokenSign(xOkapiTenant, xOkapiUrl, signTokenPayload);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthtokenApi#tokenSign");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String xOkapiTenant = new String(); // String | Okapi Tenant
final String xOkapiUrl = new String(); // String | Okapi URL
final SignTokenPayload signTokenPayload = new SignTokenPayload(); // SignTokenPayload | 

try {
    final result = await api_instance.tokenSign(xOkapiTenant, xOkapiUrl, signTokenPayload);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->tokenSign: $e\n');
}

import org.openapitools.client.api.AuthtokenApi;

public class AuthtokenApiExample {
    public static void main(String[] args) {
        AuthtokenApi apiInstance = new AuthtokenApi();
        String xOkapiTenant = xOkapiTenant_example; // String | Okapi Tenant
        String xOkapiUrl = xOkapiUrl_example; // String | Okapi URL
        SignTokenPayload signTokenPayload = ; // SignTokenPayload | 

        try {
            tokenResponse result = apiInstance.tokenSign(xOkapiTenant, xOkapiUrl, signTokenPayload);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthtokenApi#tokenSign");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AuthtokenApi *apiInstance = [[AuthtokenApi alloc] init];
String *xOkapiTenant = xOkapiTenant_example; // Okapi Tenant (default to null)
String *xOkapiUrl = xOkapiUrl_example; // Okapi URL (default to null)
SignTokenPayload *signTokenPayload = ; // 

[apiInstance tokenSignWith:xOkapiTenant
    xOkapiUrl:xOkapiUrl
    signTokenPayload:signTokenPayload
              completionHandler: ^(tokenResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ModLoginKeycloakApi = require('mod_login_keycloak_api');

// Create an instance of the API class
var api = new ModLoginKeycloakApi.AuthtokenApi()
var xOkapiTenant = xOkapiTenant_example; // {String} Okapi Tenant
var xOkapiUrl = xOkapiUrl_example; // {String} Okapi URL
var signTokenPayload = ; // {SignTokenPayload} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AuthtokenApi();
            var xOkapiTenant = xOkapiTenant_example;  // String | Okapi Tenant (default to null)
            var xOkapiUrl = xOkapiUrl_example;  // String | Okapi URL (default to null)
            var signTokenPayload = new SignTokenPayload(); // SignTokenPayload | 

            try {
                tokenResponse result = apiInstance.tokenSign(xOkapiTenant, xOkapiUrl, signTokenPayload);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthtokenApi.tokenSign: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthtokenApi();
$xOkapiTenant = xOkapiTenant_example; // String | Okapi Tenant
$xOkapiUrl = xOkapiUrl_example; // String | Okapi URL
$signTokenPayload = ; // SignTokenPayload | 

try {
    $result = $api_instance->tokenSign($xOkapiTenant, $xOkapiUrl, $signTokenPayload);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthtokenApi->tokenSign: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AuthtokenApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthtokenApi->new();
my $xOkapiTenant = xOkapiTenant_example; # String | Okapi Tenant
my $xOkapiUrl = xOkapiUrl_example; # String | Okapi URL
my $signTokenPayload = WWW::OPenAPIClient::Object::SignTokenPayload->new(); # SignTokenPayload | 

eval {
    my $result = $api_instance->tokenSign(xOkapiTenant => $xOkapiTenant, xOkapiUrl => $xOkapiUrl, signTokenPayload => $signTokenPayload);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthtokenApi->tokenSign: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.AuthtokenApi()
xOkapiTenant = xOkapiTenant_example # String | Okapi Tenant (default to null)
xOkapiUrl = xOkapiUrl_example # String | Okapi URL (default to null)
signTokenPayload =  # SignTokenPayload | 

try:
    api_response = api_instance.token_sign(xOkapiTenant, xOkapiUrl, signTokenPayload)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthtokenApi->tokenSign: %s\n" % e)

extern crate AuthtokenApi;

pub fn main() {
    let xOkapiTenant = xOkapiTenant_example; // String
    let xOkapiUrl = xOkapiUrl_example; // String
    let signTokenPayload = ; // SignTokenPayload

    let mut context = AuthtokenApi::Context::default();
    let result = client.tokenSign(xOkapiTenant, xOkapiUrl, signTokenPayload, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AuthtokenApi;

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

public class AuthtokenApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AuthtokenApi apiInstance = new AuthtokenApi();
        String xOkapiTenant = xOkapiTenant_example; // String | Okapi Tenant
        String xOkapiUrl = xOkapiUrl_example; // String | Okapi URL
        SignRefreshToken signRefreshToken = ; // SignRefreshToken | 

        try {
            token result = apiInstance.tokenSignLegacy(xOkapiTenant, xOkapiUrl, signRefreshToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthtokenApi#tokenSignLegacy");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String xOkapiTenant = new String(); // String | Okapi Tenant
final String xOkapiUrl = new String(); // String | Okapi URL
final SignRefreshToken signRefreshToken = new SignRefreshToken(); // SignRefreshToken | 

try {
    final result = await api_instance.tokenSignLegacy(xOkapiTenant, xOkapiUrl, signRefreshToken);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->tokenSignLegacy: $e\n');
}

import org.openapitools.client.api.AuthtokenApi;

public class AuthtokenApiExample {
    public static void main(String[] args) {
        AuthtokenApi apiInstance = new AuthtokenApi();
        String xOkapiTenant = xOkapiTenant_example; // String | Okapi Tenant
        String xOkapiUrl = xOkapiUrl_example; // String | Okapi URL
        SignRefreshToken signRefreshToken = ; // SignRefreshToken | 

        try {
            token result = apiInstance.tokenSignLegacy(xOkapiTenant, xOkapiUrl, signRefreshToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthtokenApi#tokenSignLegacy");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AuthtokenApi *apiInstance = [[AuthtokenApi alloc] init];
String *xOkapiTenant = xOkapiTenant_example; // Okapi Tenant (default to null)
String *xOkapiUrl = xOkapiUrl_example; // Okapi URL (default to null)
SignRefreshToken *signRefreshToken = ; // 

[apiInstance tokenSignLegacyWith:xOkapiTenant
    xOkapiUrl:xOkapiUrl
    signRefreshToken:signRefreshToken
              completionHandler: ^(token output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ModLoginKeycloakApi = require('mod_login_keycloak_api');

// Create an instance of the API class
var api = new ModLoginKeycloakApi.AuthtokenApi()
var xOkapiTenant = xOkapiTenant_example; // {String} Okapi Tenant
var xOkapiUrl = xOkapiUrl_example; // {String} Okapi URL
var signRefreshToken = ; // {SignRefreshToken} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AuthtokenApi();
            var xOkapiTenant = xOkapiTenant_example;  // String | Okapi Tenant (default to null)
            var xOkapiUrl = xOkapiUrl_example;  // String | Okapi URL (default to null)
            var signRefreshToken = new SignRefreshToken(); // SignRefreshToken | 

            try {
                token result = apiInstance.tokenSignLegacy(xOkapiTenant, xOkapiUrl, signRefreshToken);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthtokenApi.tokenSignLegacy: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthtokenApi();
$xOkapiTenant = xOkapiTenant_example; // String | Okapi Tenant
$xOkapiUrl = xOkapiUrl_example; // String | Okapi URL
$signRefreshToken = ; // SignRefreshToken | 

try {
    $result = $api_instance->tokenSignLegacy($xOkapiTenant, $xOkapiUrl, $signRefreshToken);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthtokenApi->tokenSignLegacy: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AuthtokenApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthtokenApi->new();
my $xOkapiTenant = xOkapiTenant_example; # String | Okapi Tenant
my $xOkapiUrl = xOkapiUrl_example; # String | Okapi URL
my $signRefreshToken = WWW::OPenAPIClient::Object::SignRefreshToken->new(); # SignRefreshToken | 

eval {
    my $result = $api_instance->tokenSignLegacy(xOkapiTenant => $xOkapiTenant, xOkapiUrl => $xOkapiUrl, signRefreshToken => $signRefreshToken);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthtokenApi->tokenSignLegacy: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.AuthtokenApi()
xOkapiTenant = xOkapiTenant_example # String | Okapi Tenant (default to null)
xOkapiUrl = xOkapiUrl_example # String | Okapi URL (default to null)
signRefreshToken =  # SignRefreshToken | 

try:
    api_response = api_instance.token_sign_legacy(xOkapiTenant, xOkapiUrl, signRefreshToken)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthtokenApi->tokenSignLegacy: %s\n" % e)

extern crate AuthtokenApi;

pub fn main() {
    let xOkapiTenant = xOkapiTenant_example; // String
    let xOkapiUrl = xOkapiUrl_example; // String
    let signRefreshToken = ; // SignRefreshToken

    let mut context = AuthtokenApi::Context::default();
    let result = client.tokenSignLegacy(xOkapiTenant, xOkapiUrl, signRefreshToken, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CredentialsApi;

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

public class CredentialsApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CredentialsApi apiInstance = new CredentialsApi();
        String userId = userId_example; // String | User identifier

        try {
            credentialsExistence result = apiInstance.checkCredentialsExistence(userId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CredentialsApi#checkCredentialsExistence");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String userId = new String(); // String | User identifier

try {
    final result = await api_instance.checkCredentialsExistence(userId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->checkCredentialsExistence: $e\n');
}

import org.openapitools.client.api.CredentialsApi;

public class CredentialsApiExample {
    public static void main(String[] args) {
        CredentialsApi apiInstance = new CredentialsApi();
        String userId = userId_example; // String | User identifier

        try {
            credentialsExistence result = apiInstance.checkCredentialsExistence(userId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CredentialsApi#checkCredentialsExistence");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CredentialsApi *apiInstance = [[CredentialsApi alloc] init];
String *userId = userId_example; // User identifier (default to null)

[apiInstance checkCredentialsExistenceWith:userId
              completionHandler: ^(credentialsExistence output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ModLoginKeycloakApi = require('mod_login_keycloak_api');

// Create an instance of the API class
var api = new ModLoginKeycloakApi.CredentialsApi()
var userId = userId_example; // {String} User identifier

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CredentialsApi();
            var userId = userId_example;  // String | User identifier (default to null)

            try {
                credentialsExistence result = apiInstance.checkCredentialsExistence(userId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CredentialsApi.checkCredentialsExistence: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CredentialsApi();
$userId = userId_example; // String | User identifier

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CredentialsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CredentialsApi->new();
my $userId = userId_example; # String | User identifier

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

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

# Create an instance of the API class
api_instance = openapi_client.CredentialsApi()
userId = userId_example # String | User identifier (default to null)

try:
    api_response = api_instance.check_credentials_existence(userId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CredentialsApi->checkCredentialsExistence: %s\n" % e)

extern crate CredentialsApi;

pub fn main() {
    let userId = userId_example; // String

    let mut context = CredentialsApi::Context::default();
    let result = client.checkCredentialsExistence(userId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CredentialsApi;

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

public class CredentialsApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CredentialsApi apiInstance = new CredentialsApi();
        LoginCredentials loginCredentials = ; // LoginCredentials | 

        try {
            apiInstance.createCredentials(loginCredentials);
        } catch (ApiException e) {
            System.err.println("Exception when calling CredentialsApi#createCredentials");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final LoginCredentials loginCredentials = new LoginCredentials(); // LoginCredentials | 

try {
    final result = await api_instance.createCredentials(loginCredentials);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createCredentials: $e\n');
}

import org.openapitools.client.api.CredentialsApi;

public class CredentialsApiExample {
    public static void main(String[] args) {
        CredentialsApi apiInstance = new CredentialsApi();
        LoginCredentials loginCredentials = ; // LoginCredentials | 

        try {
            apiInstance.createCredentials(loginCredentials);
        } catch (ApiException e) {
            System.err.println("Exception when calling CredentialsApi#createCredentials");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CredentialsApi *apiInstance = [[CredentialsApi alloc] init];
LoginCredentials *loginCredentials = ; // 

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

var ModLoginKeycloakApi = require('mod_login_keycloak_api');

// Create an instance of the API class
var api = new ModLoginKeycloakApi.CredentialsApi()
var loginCredentials = ; // {LoginCredentials} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CredentialsApi();
            var loginCredentials = new LoginCredentials(); // LoginCredentials | 

            try {
                apiInstance.createCredentials(loginCredentials);
            } catch (Exception e) {
                Debug.Print("Exception when calling CredentialsApi.createCredentials: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CredentialsApi();
$loginCredentials = ; // LoginCredentials | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CredentialsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CredentialsApi->new();
my $loginCredentials = WWW::OPenAPIClient::Object::LoginCredentials->new(); # LoginCredentials | 

eval {
    $api_instance->createCredentials(loginCredentials => $loginCredentials);
};
if ($@) {
    warn "Exception when calling CredentialsApi->createCredentials: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CredentialsApi()
loginCredentials =  # LoginCredentials | 

try:
    api_instance.create_credentials(loginCredentials)
except ApiException as e:
    print("Exception when calling CredentialsApi->createCredentials: %s\n" % e)

extern crate CredentialsApi;

pub fn main() {
    let loginCredentials = ; // LoginCredentials

    let mut context = CredentialsApi::Context::default();
    let result = client.createCredentials(loginCredentials, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CredentialsApi;

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

public class CredentialsApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CredentialsApi apiInstance = new CredentialsApi();
        String userId = userId_example; // String | User identifier

        try {
            apiInstance.deleteCredentials(userId);
        } catch (ApiException e) {
            System.err.println("Exception when calling CredentialsApi#deleteCredentials");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String userId = new String(); // String | User identifier

try {
    final result = await api_instance.deleteCredentials(userId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteCredentials: $e\n');
}

import org.openapitools.client.api.CredentialsApi;

public class CredentialsApiExample {
    public static void main(String[] args) {
        CredentialsApi apiInstance = new CredentialsApi();
        String userId = userId_example; // String | User identifier

        try {
            apiInstance.deleteCredentials(userId);
        } catch (ApiException e) {
            System.err.println("Exception when calling CredentialsApi#deleteCredentials");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CredentialsApi *apiInstance = [[CredentialsApi alloc] init];
String *userId = userId_example; // User identifier (default to null)

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

var ModLoginKeycloakApi = require('mod_login_keycloak_api');

// Create an instance of the API class
var api = new ModLoginKeycloakApi.CredentialsApi()
var userId = userId_example; // {String} User identifier

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CredentialsApi();
            var userId = userId_example;  // String | User identifier (default to null)

            try {
                apiInstance.deleteCredentials(userId);
            } catch (Exception e) {
                Debug.Print("Exception when calling CredentialsApi.deleteCredentials: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CredentialsApi();
$userId = userId_example; // String | User identifier

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CredentialsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CredentialsApi->new();
my $userId = userId_example; # String | User identifier

eval {
    $api_instance->deleteCredentials(userId => $userId);
};
if ($@) {
    warn "Exception when calling CredentialsApi->deleteCredentials: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CredentialsApi()
userId = userId_example # String | User identifier (default to null)

try:
    api_instance.delete_credentials(userId)
except ApiException as e:
    print("Exception when calling CredentialsApi->deleteCredentials: %s\n" % e)

extern crate CredentialsApi;

pub fn main() {
    let userId = userId_example; // String

    let mut context = CredentialsApi::Context::default();
    let result = client.deleteCredentials(userId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CredentialsApi;

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

public class CredentialsApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        CredentialsApi apiInstance = new CredentialsApi();
        UpdateCredentials updateCredentials = ; // UpdateCredentials | 
        String userAgent = userAgent_example; // String | Used to identify the Operating System and Browser of the web-server
        String forwardedFor = forwardedFor_example; // String | -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer

        try {
            apiInstance.updateCredentials(updateCredentials, userAgent, forwardedFor);
        } catch (ApiException e) {
            System.err.println("Exception when calling CredentialsApi#updateCredentials");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UpdateCredentials updateCredentials = new UpdateCredentials(); // UpdateCredentials | 
final String userAgent = new String(); // String | Used to identify the Operating System and Browser of the web-server
final String forwardedFor = new String(); // String | -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer

try {
    final result = await api_instance.updateCredentials(updateCredentials, userAgent, forwardedFor);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateCredentials: $e\n');
}

import org.openapitools.client.api.CredentialsApi;

public class CredentialsApiExample {
    public static void main(String[] args) {
        CredentialsApi apiInstance = new CredentialsApi();
        UpdateCredentials updateCredentials = ; // UpdateCredentials | 
        String userAgent = userAgent_example; // String | Used to identify the Operating System and Browser of the web-server
        String forwardedFor = forwardedFor_example; // String | -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer

        try {
            apiInstance.updateCredentials(updateCredentials, userAgent, forwardedFor);
        } catch (ApiException e) {
            System.err.println("Exception when calling CredentialsApi#updateCredentials");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
CredentialsApi *apiInstance = [[CredentialsApi alloc] init];
UpdateCredentials *updateCredentials = ; // 
String *userAgent = userAgent_example; // Used to identify the Operating System and Browser of the web-server (optional) (default to null)
String *forwardedFor = forwardedFor_example; // -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer (optional) (default to null)

[apiInstance updateCredentialsWith:updateCredentials
    userAgent:userAgent
    forwardedFor:forwardedFor
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ModLoginKeycloakApi = require('mod_login_keycloak_api');

// Create an instance of the API class
var api = new ModLoginKeycloakApi.CredentialsApi()
var updateCredentials = ; // {UpdateCredentials} 
var opts = {
  'userAgent': userAgent_example, // {String} Used to identify the Operating System and Browser of the web-server
  'forwardedFor': forwardedFor_example // {String} -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer
};

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CredentialsApi();
            var updateCredentials = new UpdateCredentials(); // UpdateCredentials | 
            var userAgent = userAgent_example;  // String | Used to identify the Operating System and Browser of the web-server (optional)  (default to null)
            var forwardedFor = forwardedFor_example;  // String | -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer (optional)  (default to null)

            try {
                apiInstance.updateCredentials(updateCredentials, userAgent, forwardedFor);
            } catch (Exception e) {
                Debug.Print("Exception when calling CredentialsApi.updateCredentials: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CredentialsApi();
$updateCredentials = ; // UpdateCredentials | 
$userAgent = userAgent_example; // String | Used to identify the Operating System and Browser of the web-server
$forwardedFor = forwardedFor_example; // String | -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer

try {
    $api_instance->updateCredentials($updateCredentials, $userAgent, $forwardedFor);
} catch (Exception $e) {
    echo 'Exception when calling CredentialsApi->updateCredentials: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CredentialsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CredentialsApi->new();
my $updateCredentials = WWW::OPenAPIClient::Object::UpdateCredentials->new(); # UpdateCredentials | 
my $userAgent = userAgent_example; # String | Used to identify the Operating System and Browser of the web-server
my $forwardedFor = forwardedFor_example; # String | -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer

eval {
    $api_instance->updateCredentials(updateCredentials => $updateCredentials, userAgent => $userAgent, forwardedFor => $forwardedFor);
};
if ($@) {
    warn "Exception when calling CredentialsApi->updateCredentials: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.CredentialsApi()
updateCredentials =  # UpdateCredentials | 
userAgent = userAgent_example # String | Used to identify the Operating System and Browser of the web-server (optional) (default to null)
forwardedFor = forwardedFor_example # String | -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer (optional) (default to null)

try:
    api_instance.update_credentials(updateCredentials, userAgent=userAgent, forwardedFor=forwardedFor)
except ApiException as e:
    print("Exception when calling CredentialsApi->updateCredentials: %s\n" % e)

extern crate CredentialsApi;

pub fn main() {
    let updateCredentials = ; // UpdateCredentials
    let userAgent = userAgent_example; // String
    let forwardedFor = forwardedFor_example; // String

    let mut context = CredentialsApi::Context::default();
    let result = client.updateCredentials(updateCredentials, userAgent, forwardedFor, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LogEventsApi;

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

public class LogEventsApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LogEventsApi apiInstance = new LogEventsApi();
        String eventId = eventId_example; // String | Event Identifier

        try {
            apiInstance.deleteLogEvent(eventId);
        } catch (ApiException e) {
            System.err.println("Exception when calling LogEventsApi#deleteLogEvent");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String eventId = new String(); // String | Event Identifier

try {
    final result = await api_instance.deleteLogEvent(eventId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteLogEvent: $e\n');
}

import org.openapitools.client.api.LogEventsApi;

public class LogEventsApiExample {
    public static void main(String[] args) {
        LogEventsApi apiInstance = new LogEventsApi();
        String eventId = eventId_example; // String | Event Identifier

        try {
            apiInstance.deleteLogEvent(eventId);
        } catch (ApiException e) {
            System.err.println("Exception when calling LogEventsApi#deleteLogEvent");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
LogEventsApi *apiInstance = [[LogEventsApi alloc] init];
String *eventId = eventId_example; // Event Identifier (default to null)

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

var ModLoginKeycloakApi = require('mod_login_keycloak_api');

// Create an instance of the API class
var api = new ModLoginKeycloakApi.LogEventsApi()
var eventId = eventId_example; // {String} Event Identifier

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new LogEventsApi();
            var eventId = eventId_example;  // String | Event Identifier (default to null)

            try {
                apiInstance.deleteLogEvent(eventId);
            } catch (Exception e) {
                Debug.Print("Exception when calling LogEventsApi.deleteLogEvent: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LogEventsApi();
$eventId = eventId_example; // String | Event Identifier

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LogEventsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LogEventsApi->new();
my $eventId = eventId_example; # String | Event Identifier

eval {
    $api_instance->deleteLogEvent(eventId => $eventId);
};
if ($@) {
    warn "Exception when calling LogEventsApi->deleteLogEvent: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.LogEventsApi()
eventId = eventId_example # String | Event Identifier (default to null)

try:
    api_instance.delete_log_event(eventId)
except ApiException as e:
    print("Exception when calling LogEventsApi->deleteLogEvent: %s\n" % e)

extern crate LogEventsApi;

pub fn main() {
    let eventId = eventId_example; // String

    let mut context = LogEventsApi::Context::default();
    let result = client.deleteLogEvent(eventId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LogEventsApi;

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

public class LogEventsApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LogEventsApi apiInstance = new LogEventsApi();
        Integer length = 10; // Integer | The maximum number of results to return.
        Integer start = 56; // Integer | The starting index in a list of results (starts at one).
        String query = 10; // String | A query string to filter users based on matching criteria in fields.

        try {
            logEventCollection result = apiInstance.getLogEvents(length, start, query);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LogEventsApi#getLogEvents");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer length = new Integer(); // Integer | The maximum number of results to return.
final Integer start = new Integer(); // Integer | The starting index in a list of results (starts at one).
final String query = new String(); // String | A query string to filter users based on matching criteria in fields.

try {
    final result = await api_instance.getLogEvents(length, start, query);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getLogEvents: $e\n');
}

import org.openapitools.client.api.LogEventsApi;

public class LogEventsApiExample {
    public static void main(String[] args) {
        LogEventsApi apiInstance = new LogEventsApi();
        Integer length = 10; // Integer | The maximum number of results to return.
        Integer start = 56; // Integer | The starting index in a list of results (starts at one).
        String query = 10; // String | A query string to filter users based on matching criteria in fields.

        try {
            logEventCollection result = apiInstance.getLogEvents(length, start, query);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LogEventsApi#getLogEvents");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
LogEventsApi *apiInstance = [[LogEventsApi alloc] init];
Integer *length = 10; // The maximum number of results to return. (optional) (default to 10)
Integer *start = 56; // The starting index in a list of results (starts at one). (optional) (default to 1)
String *query = 10; // A query string to filter users based on matching criteria in fields. (optional) (default to null)

[apiInstance getLogEventsWith:length
    start:start
    query:query
              completionHandler: ^(logEventCollection output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ModLoginKeycloakApi = require('mod_login_keycloak_api');

// Create an instance of the API class
var api = new ModLoginKeycloakApi.LogEventsApi()
var opts = {
  'length': 10, // {Integer} The maximum number of results to return.
  'start': 56, // {Integer} The starting index in a list of results (starts at one).
  'query': 10 // {String} A query string to filter users based on matching criteria in fields.
};

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new LogEventsApi();
            var length = 10;  // Integer | The maximum number of results to return. (optional)  (default to 10)
            var start = 56;  // Integer | The starting index in a list of results (starts at one). (optional)  (default to 1)
            var query = 10;  // String | A query string to filter users based on matching criteria in fields. (optional)  (default to null)

            try {
                logEventCollection result = apiInstance.getLogEvents(length, start, query);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LogEventsApi.getLogEvents: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LogEventsApi();
$length = 10; // Integer | The maximum number of results to return.
$start = 56; // Integer | The starting index in a list of results (starts at one).
$query = 10; // String | A query string to filter users based on matching criteria in fields.

try {
    $result = $api_instance->getLogEvents($length, $start, $query);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LogEventsApi->getLogEvents: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LogEventsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LogEventsApi->new();
my $length = 10; # Integer | The maximum number of results to return.
my $start = 56; # Integer | The starting index in a list of results (starts at one).
my $query = 10; # String | A query string to filter users based on matching criteria in fields.

eval {
    my $result = $api_instance->getLogEvents(length => $length, start => $start, query => $query);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LogEventsApi->getLogEvents: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.LogEventsApi()
length = 10 # Integer | The maximum number of results to return. (optional) (default to 10)
start = 56 # Integer | The starting index in a list of results (starts at one). (optional) (default to 1)
query = 10 # String | A query string to filter users based on matching criteria in fields. (optional) (default to null)

try:
    api_response = api_instance.get_log_events(length=length, start=start, query=query)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LogEventsApi->getLogEvents: %s\n" % e)

extern crate LogEventsApi;

pub fn main() {
    let length = 10; // Integer
    let start = 56; // Integer
    let query = 10; // String

    let mut context = LogEventsApi::Context::default();
    let result = client.getLogEvents(length, start, query, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LogEventsApi;

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

public class LogEventsApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LogEventsApi apiInstance = new LogEventsApi();
        LogEvent logEvent = ; // LogEvent | 

        try {
            logResponse result = apiInstance.saveLogEvent(logEvent);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LogEventsApi#saveLogEvent");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final LogEvent logEvent = new LogEvent(); // LogEvent | 

try {
    final result = await api_instance.saveLogEvent(logEvent);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->saveLogEvent: $e\n');
}

import org.openapitools.client.api.LogEventsApi;

public class LogEventsApiExample {
    public static void main(String[] args) {
        LogEventsApi apiInstance = new LogEventsApi();
        LogEvent logEvent = ; // LogEvent | 

        try {
            logResponse result = apiInstance.saveLogEvent(logEvent);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LogEventsApi#saveLogEvent");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
LogEventsApi *apiInstance = [[LogEventsApi alloc] init];
LogEvent *logEvent = ; //  (optional)

[apiInstance saveLogEventWith:logEvent
              completionHandler: ^(logResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ModLoginKeycloakApi = require('mod_login_keycloak_api');

// Create an instance of the API class
var api = new ModLoginKeycloakApi.LogEventsApi()
var opts = {
  'logEvent':  // {LogEvent} 
};

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new LogEventsApi();
            var logEvent = new LogEvent(); // LogEvent |  (optional) 

            try {
                logResponse result = apiInstance.saveLogEvent(logEvent);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LogEventsApi.saveLogEvent: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LogEventsApi();
$logEvent = ; // LogEvent | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LogEventsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LogEventsApi->new();
my $logEvent = WWW::OPenAPIClient::Object::LogEvent->new(); # LogEvent | 

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

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

# Create an instance of the API class
api_instance = openapi_client.LogEventsApi()
logEvent =  # LogEvent |  (optional)

try:
    api_response = api_instance.save_log_event(logEvent=logEvent)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LogEventsApi->saveLogEvent: %s\n" % e)

extern crate LogEventsApi;

pub fn main() {
    let logEvent = ; // LogEvent

    let mut context = LogEventsApi::Context::default();
    let result = client.saveLogEvent(logEvent, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LoginApi;

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

public class LoginApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LoginApi apiInstance = new LoginApi();
        LoginCredentials loginCredentials = ; // LoginCredentials | 
        String userAgent = userAgent_example; // String | Used to identify the Operating System and Browser of the web-server
        String forwardedFor = forwardedFor_example; // String | -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer

        try {
            loginResponse result = apiInstance.login(loginCredentials, userAgent, forwardedFor);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginApi#login");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final LoginCredentials loginCredentials = new LoginCredentials(); // LoginCredentials | 
final String userAgent = new String(); // String | Used to identify the Operating System and Browser of the web-server
final String forwardedFor = new String(); // String | -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer

try {
    final result = await api_instance.login(loginCredentials, userAgent, forwardedFor);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->login: $e\n');
}

import org.openapitools.client.api.LoginApi;

public class LoginApiExample {
    public static void main(String[] args) {
        LoginApi apiInstance = new LoginApi();
        LoginCredentials loginCredentials = ; // LoginCredentials | 
        String userAgent = userAgent_example; // String | Used to identify the Operating System and Browser of the web-server
        String forwardedFor = forwardedFor_example; // String | -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer

        try {
            loginResponse result = apiInstance.login(loginCredentials, userAgent, forwardedFor);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginApi#login");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
LoginApi *apiInstance = [[LoginApi alloc] init];
LoginCredentials *loginCredentials = ; // 
String *userAgent = userAgent_example; // Used to identify the Operating System and Browser of the web-server (optional) (default to null)
String *forwardedFor = forwardedFor_example; // -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer (optional) (default to null)

[apiInstance loginWith:loginCredentials
    userAgent:userAgent
    forwardedFor:forwardedFor
              completionHandler: ^(loginResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ModLoginKeycloakApi = require('mod_login_keycloak_api');

// Create an instance of the API class
var api = new ModLoginKeycloakApi.LoginApi()
var loginCredentials = ; // {LoginCredentials} 
var opts = {
  'userAgent': userAgent_example, // {String} Used to identify the Operating System and Browser of the web-server
  'forwardedFor': forwardedFor_example // {String} -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer
};

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new LoginApi();
            var loginCredentials = new LoginCredentials(); // LoginCredentials | 
            var userAgent = userAgent_example;  // String | Used to identify the Operating System and Browser of the web-server (optional)  (default to null)
            var forwardedFor = forwardedFor_example;  // String | -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer (optional)  (default to null)

            try {
                loginResponse result = apiInstance.login(loginCredentials, userAgent, forwardedFor);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginApi.login: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LoginApi();
$loginCredentials = ; // LoginCredentials | 
$userAgent = userAgent_example; // String | Used to identify the Operating System and Browser of the web-server
$forwardedFor = forwardedFor_example; // String | -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer

try {
    $result = $api_instance->login($loginCredentials, $userAgent, $forwardedFor);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LoginApi->login: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LoginApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LoginApi->new();
my $loginCredentials = WWW::OPenAPIClient::Object::LoginCredentials->new(); # LoginCredentials | 
my $userAgent = userAgent_example; # String | Used to identify the Operating System and Browser of the web-server
my $forwardedFor = forwardedFor_example; # String | -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer

eval {
    my $result = $api_instance->login(loginCredentials => $loginCredentials, userAgent => $userAgent, forwardedFor => $forwardedFor);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LoginApi->login: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.LoginApi()
loginCredentials =  # LoginCredentials | 
userAgent = userAgent_example # String | Used to identify the Operating System and Browser of the web-server (optional) (default to null)
forwardedFor = forwardedFor_example # String | -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer (optional) (default to null)

try:
    api_response = api_instance.login(loginCredentials, userAgent=userAgent, forwardedFor=forwardedFor)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LoginApi->login: %s\n" % e)

extern crate LoginApi;

pub fn main() {
    let loginCredentials = ; // LoginCredentials
    let userAgent = userAgent_example; // String
    let forwardedFor = forwardedFor_example; // String

    let mut context = LoginApi::Context::default();
    let result = client.login(loginCredentials, userAgent, forwardedFor, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LoginApi;

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

public class LoginApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LoginApi apiInstance = new LoginApi();
        LoginCredentials loginCredentials = ; // LoginCredentials | 
        String userAgent = userAgent_example; // String | Used to identify the Operating System and Browser of the web-server
        String forwardedFor = forwardedFor_example; // String | -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer

        try {
            loginResponseWithExpiry result = apiInstance.loginWithExpiry(loginCredentials, userAgent, forwardedFor);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginApi#loginWithExpiry");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final LoginCredentials loginCredentials = new LoginCredentials(); // LoginCredentials | 
final String userAgent = new String(); // String | Used to identify the Operating System and Browser of the web-server
final String forwardedFor = new String(); // String | -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer

try {
    final result = await api_instance.loginWithExpiry(loginCredentials, userAgent, forwardedFor);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->loginWithExpiry: $e\n');
}

import org.openapitools.client.api.LoginApi;

public class LoginApiExample {
    public static void main(String[] args) {
        LoginApi apiInstance = new LoginApi();
        LoginCredentials loginCredentials = ; // LoginCredentials | 
        String userAgent = userAgent_example; // String | Used to identify the Operating System and Browser of the web-server
        String forwardedFor = forwardedFor_example; // String | -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer

        try {
            loginResponseWithExpiry result = apiInstance.loginWithExpiry(loginCredentials, userAgent, forwardedFor);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginApi#loginWithExpiry");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
LoginApi *apiInstance = [[LoginApi alloc] init];
LoginCredentials *loginCredentials = ; // 
String *userAgent = userAgent_example; // Used to identify the Operating System and Browser of the web-server (optional) (default to null)
String *forwardedFor = forwardedFor_example; // -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer (optional) (default to null)

[apiInstance loginWithExpiryWith:loginCredentials
    userAgent:userAgent
    forwardedFor:forwardedFor
              completionHandler: ^(loginResponseWithExpiry output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ModLoginKeycloakApi = require('mod_login_keycloak_api');

// Create an instance of the API class
var api = new ModLoginKeycloakApi.LoginApi()
var loginCredentials = ; // {LoginCredentials} 
var opts = {
  'userAgent': userAgent_example, // {String} Used to identify the Operating System and Browser of the web-server
  'forwardedFor': forwardedFor_example // {String} -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer
};

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new LoginApi();
            var loginCredentials = new LoginCredentials(); // LoginCredentials | 
            var userAgent = userAgent_example;  // String | Used to identify the Operating System and Browser of the web-server (optional)  (default to null)
            var forwardedFor = forwardedFor_example;  // String | -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer (optional)  (default to null)

            try {
                loginResponseWithExpiry result = apiInstance.loginWithExpiry(loginCredentials, userAgent, forwardedFor);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginApi.loginWithExpiry: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LoginApi();
$loginCredentials = ; // LoginCredentials | 
$userAgent = userAgent_example; // String | Used to identify the Operating System and Browser of the web-server
$forwardedFor = forwardedFor_example; // String | -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer

try {
    $result = $api_instance->loginWithExpiry($loginCredentials, $userAgent, $forwardedFor);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LoginApi->loginWithExpiry: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LoginApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LoginApi->new();
my $loginCredentials = WWW::OPenAPIClient::Object::LoginCredentials->new(); # LoginCredentials | 
my $userAgent = userAgent_example; # String | Used to identify the Operating System and Browser of the web-server
my $forwardedFor = forwardedFor_example; # String | -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer

eval {
    my $result = $api_instance->loginWithExpiry(loginCredentials => $loginCredentials, userAgent => $userAgent, forwardedFor => $forwardedFor);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LoginApi->loginWithExpiry: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.LoginApi()
loginCredentials =  # LoginCredentials | 
userAgent = userAgent_example # String | Used to identify the Operating System and Browser of the web-server (optional) (default to null)
forwardedFor = forwardedFor_example # String | -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer (optional) (default to null)

try:
    api_response = api_instance.login_with_expiry(loginCredentials, userAgent=userAgent, forwardedFor=forwardedFor)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LoginApi->loginWithExpiry: %s\n" % e)

extern crate LoginApi;

pub fn main() {
    let loginCredentials = ; // LoginCredentials
    let userAgent = userAgent_example; // String
    let forwardedFor = forwardedFor_example; // String

    let mut context = LoginApi::Context::default();
    let result = client.loginWithExpiry(loginCredentials, userAgent, forwardedFor, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LoginApi;

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

public class LoginApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LoginApi apiInstance = new LoginApi();
        String folioRefreshToken = folioRefreshToken_example; // String | Refresh token cookie

        try {
            apiInstance.logout(folioRefreshToken);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginApi#logout");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String folioRefreshToken = new String(); // String | Refresh token cookie

try {
    final result = await api_instance.logout(folioRefreshToken);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->logout: $e\n');
}

import org.openapitools.client.api.LoginApi;

public class LoginApiExample {
    public static void main(String[] args) {
        LoginApi apiInstance = new LoginApi();
        String folioRefreshToken = folioRefreshToken_example; // String | Refresh token cookie

        try {
            apiInstance.logout(folioRefreshToken);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginApi#logout");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
LoginApi *apiInstance = [[LoginApi alloc] init];
String *folioRefreshToken = folioRefreshToken_example; // Refresh token cookie (optional) (default to null)

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

var ModLoginKeycloakApi = require('mod_login_keycloak_api');

// Create an instance of the API class
var api = new ModLoginKeycloakApi.LoginApi()
var opts = {
  'folioRefreshToken': folioRefreshToken_example // {String} Refresh token cookie
};

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new LoginApi();
            var folioRefreshToken = folioRefreshToken_example;  // String | Refresh token cookie (optional)  (default to null)

            try {
                apiInstance.logout(folioRefreshToken);
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginApi.logout: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LoginApi();
$folioRefreshToken = folioRefreshToken_example; // String | Refresh token cookie

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LoginApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LoginApi->new();
my $folioRefreshToken = folioRefreshToken_example; # String | Refresh token cookie

eval {
    $api_instance->logout(folioRefreshToken => $folioRefreshToken);
};
if ($@) {
    warn "Exception when calling LoginApi->logout: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.LoginApi()
folioRefreshToken = folioRefreshToken_example # String | Refresh token cookie (optional) (default to null)

try:
    api_instance.logout(folioRefreshToken=folioRefreshToken)
except ApiException as e:
    print("Exception when calling LoginApi->logout: %s\n" % e)

extern crate LoginApi;

pub fn main() {
    let folioRefreshToken = folioRefreshToken_example; // String

    let mut context = LoginApi::Context::default();
    let result = client.logout(folioRefreshToken, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LoginApi;

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

public class LoginApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LoginApi apiInstance = new LoginApi();

        try {
            apiInstance.logoutAll();
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginApi#logoutAll");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.logoutAll();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->logoutAll: $e\n');
}

import org.openapitools.client.api.LoginApi;

public class LoginApiExample {
    public static void main(String[] args) {
        LoginApi apiInstance = new LoginApi();

        try {
            apiInstance.logoutAll();
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginApi#logoutAll");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
LoginApi *apiInstance = [[LoginApi alloc] init];

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

var ModLoginKeycloakApi = require('mod_login_keycloak_api');

// Create an instance of the API class
var api = new ModLoginKeycloakApi.LoginApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.logoutAll(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new LoginApi();

            try {
                apiInstance.logoutAll();
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginApi.logoutAll: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LoginApi();

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LoginApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LoginApi->new();

eval {
    $api_instance->logoutAll();
};
if ($@) {
    warn "Exception when calling LoginApi->logoutAll: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.LoginApi()

try:
    api_instance.logout_all()
except ApiException as e:
    print("Exception when calling LoginApi->logoutAll: %s\n" % e)

extern crate LoginApi;

pub fn main() {

    let mut context = LoginApi::Context::default();
    let result = client.logoutAll(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LoginApi;

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

public class LoginApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LoginApi apiInstance = new LoginApi();
        String folioRefreshToken = folioRefreshToken_example; // String | Refresh token cookie

        try {
            loginResponseWithExpiry result = apiInstance.refreshToken(folioRefreshToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginApi#refreshToken");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String folioRefreshToken = new String(); // String | Refresh token cookie

try {
    final result = await api_instance.refreshToken(folioRefreshToken);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->refreshToken: $e\n');
}

import org.openapitools.client.api.LoginApi;

public class LoginApiExample {
    public static void main(String[] args) {
        LoginApi apiInstance = new LoginApi();
        String folioRefreshToken = folioRefreshToken_example; // String | Refresh token cookie

        try {
            loginResponseWithExpiry result = apiInstance.refreshToken(folioRefreshToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginApi#refreshToken");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
LoginApi *apiInstance = [[LoginApi alloc] init];
String *folioRefreshToken = folioRefreshToken_example; // Refresh token cookie (default to null)

[apiInstance refreshTokenWith:folioRefreshToken
              completionHandler: ^(loginResponseWithExpiry output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ModLoginKeycloakApi = require('mod_login_keycloak_api');

// Create an instance of the API class
var api = new ModLoginKeycloakApi.LoginApi()
var folioRefreshToken = folioRefreshToken_example; // {String} Refresh token cookie

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new LoginApi();
            var folioRefreshToken = folioRefreshToken_example;  // String | Refresh token cookie (default to null)

            try {
                loginResponseWithExpiry result = apiInstance.refreshToken(folioRefreshToken);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginApi.refreshToken: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LoginApi();
$folioRefreshToken = folioRefreshToken_example; // String | Refresh token cookie

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LoginApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LoginApi->new();
my $folioRefreshToken = folioRefreshToken_example; # String | Refresh token cookie

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

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

# Create an instance of the API class
api_instance = openapi_client.LoginApi()
folioRefreshToken = folioRefreshToken_example # String | Refresh token cookie (default to null)

try:
    api_response = api_instance.refresh_token(folioRefreshToken)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LoginApi->refreshToken: %s\n" % e)

extern crate LoginApi;

pub fn main() {
    let folioRefreshToken = folioRefreshToken_example; // String

    let mut context = LoginApi::Context::default();
    let result = client.refreshToken(folioRefreshToken, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LoginApi;

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

public class LoginApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LoginApi apiInstance = new LoginApi();
        String code = code_example; // String | temporary authentication code
        String redirectUri = redirectUri_example; // String | initial uri that was used as redirect uri for getting authentication code
        String userAgent = userAgent_example; // String | Used to identify the Operating System and Browser of the web-server
        String forwardedFor = forwardedFor_example; // String | -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer

        try {
            loginResponseWithExpiry result = apiInstance.token(code, redirectUri, userAgent, forwardedFor);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginApi#token");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String code = new String(); // String | temporary authentication code
final String redirectUri = new String(); // String | initial uri that was used as redirect uri for getting authentication code
final String userAgent = new String(); // String | Used to identify the Operating System and Browser of the web-server
final String forwardedFor = new String(); // String | -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer

try {
    final result = await api_instance.token(code, redirectUri, userAgent, forwardedFor);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->token: $e\n');
}

import org.openapitools.client.api.LoginApi;

public class LoginApiExample {
    public static void main(String[] args) {
        LoginApi apiInstance = new LoginApi();
        String code = code_example; // String | temporary authentication code
        String redirectUri = redirectUri_example; // String | initial uri that was used as redirect uri for getting authentication code
        String userAgent = userAgent_example; // String | Used to identify the Operating System and Browser of the web-server
        String forwardedFor = forwardedFor_example; // String | -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer

        try {
            loginResponseWithExpiry result = apiInstance.token(code, redirectUri, userAgent, forwardedFor);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginApi#token");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
LoginApi *apiInstance = [[LoginApi alloc] init];
String *code = code_example; // temporary authentication code (default to null)
String *redirectUri = redirectUri_example; // initial uri that was used as redirect uri for getting authentication code (default to null)
String *userAgent = userAgent_example; // Used to identify the Operating System and Browser of the web-server (optional) (default to null)
String *forwardedFor = forwardedFor_example; // -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer (optional) (default to null)

[apiInstance tokenWith:code
    redirectUri:redirectUri
    userAgent:userAgent
    forwardedFor:forwardedFor
              completionHandler: ^(loginResponseWithExpiry output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ModLoginKeycloakApi = require('mod_login_keycloak_api');

// Create an instance of the API class
var api = new ModLoginKeycloakApi.LoginApi()
var code = code_example; // {String} temporary authentication code
var redirectUri = redirectUri_example; // {String} initial uri that was used as redirect uri for getting authentication code
var opts = {
  'userAgent': userAgent_example, // {String} Used to identify the Operating System and Browser of the web-server
  'forwardedFor': forwardedFor_example // {String} -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer
};

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new LoginApi();
            var code = code_example;  // String | temporary authentication code (default to null)
            var redirectUri = redirectUri_example;  // String | initial uri that was used as redirect uri for getting authentication code (default to null)
            var userAgent = userAgent_example;  // String | Used to identify the Operating System and Browser of the web-server (optional)  (default to null)
            var forwardedFor = forwardedFor_example;  // String | -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer (optional)  (default to null)

            try {
                loginResponseWithExpiry result = apiInstance.token(code, redirectUri, userAgent, forwardedFor);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginApi.token: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LoginApi();
$code = code_example; // String | temporary authentication code
$redirectUri = redirectUri_example; // String | initial uri that was used as redirect uri for getting authentication code
$userAgent = userAgent_example; // String | Used to identify the Operating System and Browser of the web-server
$forwardedFor = forwardedFor_example; // String | -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer

try {
    $result = $api_instance->token($code, $redirectUri, $userAgent, $forwardedFor);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LoginApi->token: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LoginApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LoginApi->new();
my $code = code_example; # String | temporary authentication code
my $redirectUri = redirectUri_example; # String | initial uri that was used as redirect uri for getting authentication code
my $userAgent = userAgent_example; # String | Used to identify the Operating System and Browser of the web-server
my $forwardedFor = forwardedFor_example; # String | -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer

eval {
    my $result = $api_instance->token(code => $code, redirectUri => $redirectUri, userAgent => $userAgent, forwardedFor => $forwardedFor);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LoginApi->token: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.LoginApi()
code = code_example # String | temporary authentication code (default to null)
redirectUri = redirectUri_example # String | initial uri that was used as redirect uri for getting authentication code (default to null)
userAgent = userAgent_example # String | Used to identify the Operating System and Browser of the web-server (optional) (default to null)
forwardedFor = forwardedFor_example # String | -< HTTP header field is a common method for identifying the originating IP address of a client connecting to a web server through an HTTP proxy or load balancer (optional) (default to null)

try:
    api_response = api_instance.token(code, redirectUri, userAgent=userAgent, forwardedFor=forwardedFor)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LoginApi->token: %s\n" % e)

extern crate LoginApi;

pub fn main() {
    let code = code_example; // String
    let redirectUri = redirectUri_example; // String
    let userAgent = userAgent_example; // String
    let forwardedFor = forwardedFor_example; // String

    let mut context = LoginApi::Context::default();
    let result = client.token(code, redirectUri, userAgent, forwardedFor, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LoginAttemptsApi;

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

public class LoginAttemptsApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LoginAttemptsApi apiInstance = new LoginAttemptsApi();
        String userId = userId_example; // String | User identifier

        try {
            loginAttempts result = apiInstance.getLoginAttempts(userId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginAttemptsApi#getLoginAttempts");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String userId = new String(); // String | User identifier

try {
    final result = await api_instance.getLoginAttempts(userId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getLoginAttempts: $e\n');
}

import org.openapitools.client.api.LoginAttemptsApi;

public class LoginAttemptsApiExample {
    public static void main(String[] args) {
        LoginAttemptsApi apiInstance = new LoginAttemptsApi();
        String userId = userId_example; // String | User identifier

        try {
            loginAttempts result = apiInstance.getLoginAttempts(userId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginAttemptsApi#getLoginAttempts");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
LoginAttemptsApi *apiInstance = [[LoginAttemptsApi alloc] init];
String *userId = userId_example; // User identifier (default to null)

[apiInstance getLoginAttemptsWith:userId
              completionHandler: ^(loginAttempts output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ModLoginKeycloakApi = require('mod_login_keycloak_api');

// Create an instance of the API class
var api = new ModLoginKeycloakApi.LoginAttemptsApi()
var userId = userId_example; // {String} User identifier

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new LoginAttemptsApi();
            var userId = userId_example;  // String | User identifier (default to null)

            try {
                loginAttempts result = apiInstance.getLoginAttempts(userId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginAttemptsApi.getLoginAttempts: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LoginAttemptsApi();
$userId = userId_example; // String | User identifier

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LoginAttemptsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LoginAttemptsApi->new();
my $userId = userId_example; # String | User identifier

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

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

# Create an instance of the API class
api_instance = openapi_client.LoginAttemptsApi()
userId = userId_example # String | User identifier (default to null)

try:
    api_response = api_instance.get_login_attempts(userId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LoginAttemptsApi->getLoginAttempts: %s\n" % e)

extern crate LoginAttemptsApi;

pub fn main() {
    let userId = userId_example; // String

    let mut context = LoginAttemptsApi::Context::default();
    let result = client.getLoginAttempts(userId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PasswordApi;

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

public class PasswordApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        PasswordApi apiInstance = new PasswordApi();
        PasswordCreateAction passwordCreateAction = ; // PasswordCreateAction | 

        try {
            responseCreateAction result = apiInstance.createResetPasswordAction(passwordCreateAction);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PasswordApi#createResetPasswordAction");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final PasswordCreateAction passwordCreateAction = new PasswordCreateAction(); // PasswordCreateAction | 

try {
    final result = await api_instance.createResetPasswordAction(passwordCreateAction);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createResetPasswordAction: $e\n');
}

import org.openapitools.client.api.PasswordApi;

public class PasswordApiExample {
    public static void main(String[] args) {
        PasswordApi apiInstance = new PasswordApi();
        PasswordCreateAction passwordCreateAction = ; // PasswordCreateAction | 

        try {
            responseCreateAction result = apiInstance.createResetPasswordAction(passwordCreateAction);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PasswordApi#createResetPasswordAction");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
PasswordApi *apiInstance = [[PasswordApi alloc] init];
PasswordCreateAction *passwordCreateAction = ; // 

[apiInstance createResetPasswordActionWith:passwordCreateAction
              completionHandler: ^(responseCreateAction output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ModLoginKeycloakApi = require('mod_login_keycloak_api');

// Create an instance of the API class
var api = new ModLoginKeycloakApi.PasswordApi()
var passwordCreateAction = ; // {PasswordCreateAction} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new PasswordApi();
            var passwordCreateAction = new PasswordCreateAction(); // PasswordCreateAction | 

            try {
                responseCreateAction result = apiInstance.createResetPasswordAction(passwordCreateAction);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PasswordApi.createResetPasswordAction: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PasswordApi();
$passwordCreateAction = ; // PasswordCreateAction | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PasswordApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PasswordApi->new();
my $passwordCreateAction = WWW::OPenAPIClient::Object::PasswordCreateAction->new(); # PasswordCreateAction | 

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

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

# Create an instance of the API class
api_instance = openapi_client.PasswordApi()
passwordCreateAction =  # PasswordCreateAction | 

try:
    api_response = api_instance.create_reset_password_action(passwordCreateAction)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PasswordApi->createResetPasswordAction: %s\n" % e)

extern crate PasswordApi;

pub fn main() {
    let passwordCreateAction = ; // PasswordCreateAction

    let mut context = PasswordApi::Context::default();
    let result = client.createResetPasswordAction(passwordCreateAction, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PasswordApi;

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

public class PasswordApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        PasswordApi apiInstance = new PasswordApi();
        String actionId = actionId_example; // String | Action Identifier

        try {
            passwordCreateAction result = apiInstance.getPasswordActionById(actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PasswordApi#getPasswordActionById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String actionId = new String(); // String | Action Identifier

try {
    final result = await api_instance.getPasswordActionById(actionId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getPasswordActionById: $e\n');
}

import org.openapitools.client.api.PasswordApi;

public class PasswordApiExample {
    public static void main(String[] args) {
        PasswordApi apiInstance = new PasswordApi();
        String actionId = actionId_example; // String | Action Identifier

        try {
            passwordCreateAction result = apiInstance.getPasswordActionById(actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PasswordApi#getPasswordActionById");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
PasswordApi *apiInstance = [[PasswordApi alloc] init];
String *actionId = actionId_example; // Action Identifier (default to null)

[apiInstance getPasswordActionByIdWith:actionId
              completionHandler: ^(passwordCreateAction output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ModLoginKeycloakApi = require('mod_login_keycloak_api');

// Create an instance of the API class
var api = new ModLoginKeycloakApi.PasswordApi()
var actionId = actionId_example; // {String} Action Identifier

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new PasswordApi();
            var actionId = actionId_example;  // String | Action Identifier (default to null)

            try {
                passwordCreateAction result = apiInstance.getPasswordActionById(actionId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PasswordApi.getPasswordActionById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PasswordApi();
$actionId = actionId_example; // String | Action Identifier

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PasswordApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PasswordApi->new();
my $actionId = actionId_example; # String | Action Identifier

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

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

# Create an instance of the API class
api_instance = openapi_client.PasswordApi()
actionId = actionId_example # String | Action Identifier (default to null)

try:
    api_response = api_instance.get_password_action_by_id(actionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PasswordApi->getPasswordActionById: %s\n" % e)

extern crate PasswordApi;

pub fn main() {
    let actionId = actionId_example; // String

    let mut context = PasswordApi::Context::default();
    let result = client.getPasswordActionById(actionId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PasswordApi;

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

public class PasswordApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        PasswordApi apiInstance = new PasswordApi();
        PasswordResetAction passwordResetAction = ; // PasswordResetAction | 

        try {
            responseResetAction result = apiInstance.resetPassword(passwordResetAction);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PasswordApi#resetPassword");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final PasswordResetAction passwordResetAction = new PasswordResetAction(); // PasswordResetAction | 

try {
    final result = await api_instance.resetPassword(passwordResetAction);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->resetPassword: $e\n');
}

import org.openapitools.client.api.PasswordApi;

public class PasswordApiExample {
    public static void main(String[] args) {
        PasswordApi apiInstance = new PasswordApi();
        PasswordResetAction passwordResetAction = ; // PasswordResetAction | 

        try {
            responseResetAction result = apiInstance.resetPassword(passwordResetAction);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PasswordApi#resetPassword");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
PasswordApi *apiInstance = [[PasswordApi alloc] init];
PasswordResetAction *passwordResetAction = ; // 

[apiInstance resetPasswordWith:passwordResetAction
              completionHandler: ^(responseResetAction output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ModLoginKeycloakApi = require('mod_login_keycloak_api');

// Create an instance of the API class
var api = new ModLoginKeycloakApi.PasswordApi()
var passwordResetAction = ; // {PasswordResetAction} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new PasswordApi();
            var passwordResetAction = new PasswordResetAction(); // PasswordResetAction | 

            try {
                responseResetAction result = apiInstance.resetPassword(passwordResetAction);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PasswordApi.resetPassword: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PasswordApi();
$passwordResetAction = ; // PasswordResetAction | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PasswordApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PasswordApi->new();
my $passwordResetAction = WWW::OPenAPIClient::Object::PasswordResetAction->new(); # PasswordResetAction | 

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

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

# Create an instance of the API class
api_instance = openapi_client.PasswordApi()
passwordResetAction =  # PasswordResetAction | 

try:
    api_response = api_instance.reset_password(passwordResetAction)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PasswordApi->resetPassword: %s\n" % e)

extern crate PasswordApi;

pub fn main() {
    let passwordResetAction = ; // PasswordResetAction

    let mut context = PasswordApi::Context::default();
    let result = client.resetPassword(passwordResetAction, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PasswordApi;

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

public class PasswordApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        PasswordApi apiInstance = new PasswordApi();
        Password password = ; // Password | 

        try {
            validPasswordResponse result = apiInstance.validatePasswordRepeatability(password);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PasswordApi#validatePasswordRepeatability");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Password password = new Password(); // Password | 

try {
    final result = await api_instance.validatePasswordRepeatability(password);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->validatePasswordRepeatability: $e\n');
}

import org.openapitools.client.api.PasswordApi;

public class PasswordApiExample {
    public static void main(String[] args) {
        PasswordApi apiInstance = new PasswordApi();
        Password password = ; // Password | 

        try {
            validPasswordResponse result = apiInstance.validatePasswordRepeatability(password);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PasswordApi#validatePasswordRepeatability");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
PasswordApi *apiInstance = [[PasswordApi alloc] init];
Password *password = ; // 

[apiInstance validatePasswordRepeatabilityWith:password
              completionHandler: ^(validPasswordResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var ModLoginKeycloakApi = require('mod_login_keycloak_api');

// Create an instance of the API class
var api = new ModLoginKeycloakApi.PasswordApi()
var password = ; // {Password} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new PasswordApi();
            var password = new Password(); // Password | 

            try {
                validPasswordResponse result = apiInstance.validatePasswordRepeatability(password);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PasswordApi.validatePasswordRepeatability: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PasswordApi();
$password = ; // Password | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PasswordApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PasswordApi->new();
my $password = WWW::OPenAPIClient::Object::Password->new(); # Password | 

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

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

# Create an instance of the API class
api_instance = openapi_client.PasswordApi()
password =  # Password | 

try:
    api_response = api_instance.validate_password_repeatability(password)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PasswordApi->validatePasswordRepeatability: %s\n" % e)

extern crate PasswordApi;

pub fn main() {
    let password = ; // Password

    let mut context = PasswordApi::Context::default();
    let result = client.validatePasswordRepeatability(password, &context).wait();

    println!("{:?}", result);
}