nevisFIDO REST API

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

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

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

        // Create an instance of the API class
        Fido2AuthenticationServiceApi apiInstance = new Fido2AuthenticationServiceApi();
        ServerPublicKeyCredentialForAuthentication serverPublicKeyCredentialForAuthentication = ; // ServerPublicKeyCredentialForAuthentication | 

        try {
            ServerResponse result = apiInstance.submitAssertion(serverPublicKeyCredentialForAuthentication);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Fido2AuthenticationServiceApi#submitAssertion");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ServerPublicKeyCredentialForAuthentication serverPublicKeyCredentialForAuthentication = new ServerPublicKeyCredentialForAuthentication(); // ServerPublicKeyCredentialForAuthentication | 

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

import org.openapitools.client.api.Fido2AuthenticationServiceApi;

public class Fido2AuthenticationServiceApiExample {
    public static void main(String[] args) {
        Fido2AuthenticationServiceApi apiInstance = new Fido2AuthenticationServiceApi();
        ServerPublicKeyCredentialForAuthentication serverPublicKeyCredentialForAuthentication = ; // ServerPublicKeyCredentialForAuthentication | 

        try {
            ServerResponse result = apiInstance.submitAssertion(serverPublicKeyCredentialForAuthentication);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Fido2AuthenticationServiceApi#submitAssertion");
            e.printStackTrace();
        }
    }
}

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

// WebAuthn authentication ceremony endpoint
[apiInstance submitAssertionWith:serverPublicKeyCredentialForAuthentication
              completionHandler: ^(ServerResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisFidoRestApi = require('nevis_fido_rest_api');

// Create an instance of the API class
var api = new NevisFidoRestApi.Fido2AuthenticationServiceApi()
var serverPublicKeyCredentialForAuthentication = ; // {ServerPublicKeyCredentialForAuthentication} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new Fido2AuthenticationServiceApi();
            var serverPublicKeyCredentialForAuthentication = new ServerPublicKeyCredentialForAuthentication(); // ServerPublicKeyCredentialForAuthentication | 

            try {
                // WebAuthn authentication ceremony endpoint
                ServerResponse result = apiInstance.submitAssertion(serverPublicKeyCredentialForAuthentication);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling Fido2AuthenticationServiceApi.submitAssertion: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Fido2AuthenticationServiceApi();
$serverPublicKeyCredentialForAuthentication = ; // ServerPublicKeyCredentialForAuthentication | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::Fido2AuthenticationServiceApi->new();
my $serverPublicKeyCredentialForAuthentication = WWW::OPenAPIClient::Object::ServerPublicKeyCredentialForAuthentication->new(); # ServerPublicKeyCredentialForAuthentication | 

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

try:
    # WebAuthn authentication ceremony endpoint
    api_response = api_instance.submit_assertion(serverPublicKeyCredentialForAuthentication)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Fido2AuthenticationServiceApi->submitAssertion: %s\n" % e)

extern crate Fido2AuthenticationServiceApi;

pub fn main() {
    let serverPublicKeyCredentialForAuthentication = ; // ServerPublicKeyCredentialForAuthentication

    let mut context = Fido2AuthenticationServiceApi::Context::default();
    let result = client.submitAssertion(serverPublicKeyCredentialForAuthentication, &context).wait();

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

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

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

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

        // Create an instance of the API class
        Fido2OptionsServiceApi apiInstance = new Fido2OptionsServiceApi();
        ServerPublicKeyCredentialGetOptionsRequest serverPublicKeyCredentialGetOptionsRequest = ; // ServerPublicKeyCredentialGetOptionsRequest | 

        try {
            ServerPublicKeyCredentialGetOptionsResponse result = apiInstance.getAssertionOptions(serverPublicKeyCredentialGetOptionsRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Fido2OptionsServiceApi#getAssertionOptions");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ServerPublicKeyCredentialGetOptionsRequest serverPublicKeyCredentialGetOptionsRequest = new ServerPublicKeyCredentialGetOptionsRequest(); // ServerPublicKeyCredentialGetOptionsRequest | 

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

import org.openapitools.client.api.Fido2OptionsServiceApi;

public class Fido2OptionsServiceApiExample {
    public static void main(String[] args) {
        Fido2OptionsServiceApi apiInstance = new Fido2OptionsServiceApi();
        ServerPublicKeyCredentialGetOptionsRequest serverPublicKeyCredentialGetOptionsRequest = ; // ServerPublicKeyCredentialGetOptionsRequest | 

        try {
            ServerPublicKeyCredentialGetOptionsResponse result = apiInstance.getAssertionOptions(serverPublicKeyCredentialGetOptionsRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Fido2OptionsServiceApi#getAssertionOptions");
            e.printStackTrace();
        }
    }
}

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

// FIDO2 options response
[apiInstance getAssertionOptionsWith:serverPublicKeyCredentialGetOptionsRequest
              completionHandler: ^(ServerPublicKeyCredentialGetOptionsResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisFidoRestApi = require('nevis_fido_rest_api');

// Create an instance of the API class
var api = new NevisFidoRestApi.Fido2OptionsServiceApi()
var serverPublicKeyCredentialGetOptionsRequest = ; // {ServerPublicKeyCredentialGetOptionsRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new Fido2OptionsServiceApi();
            var serverPublicKeyCredentialGetOptionsRequest = new ServerPublicKeyCredentialGetOptionsRequest(); // ServerPublicKeyCredentialGetOptionsRequest | 

            try {
                // FIDO2 options response
                ServerPublicKeyCredentialGetOptionsResponse result = apiInstance.getAssertionOptions(serverPublicKeyCredentialGetOptionsRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling Fido2OptionsServiceApi.getAssertionOptions: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Fido2OptionsServiceApi();
$serverPublicKeyCredentialGetOptionsRequest = ; // ServerPublicKeyCredentialGetOptionsRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::Fido2OptionsServiceApi->new();
my $serverPublicKeyCredentialGetOptionsRequest = WWW::OPenAPIClient::Object::ServerPublicKeyCredentialGetOptionsRequest->new(); # ServerPublicKeyCredentialGetOptionsRequest | 

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

try:
    # FIDO2 options response
    api_response = api_instance.get_assertion_options(serverPublicKeyCredentialGetOptionsRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Fido2OptionsServiceApi->getAssertionOptions: %s\n" % e)

extern crate Fido2OptionsServiceApi;

pub fn main() {
    let serverPublicKeyCredentialGetOptionsRequest = ; // ServerPublicKeyCredentialGetOptionsRequest

    let mut context = Fido2OptionsServiceApi::Context::default();
    let result = client.getAssertionOptions(serverPublicKeyCredentialGetOptionsRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        Fido2OptionsServiceApi apiInstance = new Fido2OptionsServiceApi();
        ServerPublicKeyCredentialCreationOptionsRequest serverPublicKeyCredentialCreationOptionsRequest = ; // ServerPublicKeyCredentialCreationOptionsRequest | 

        try {
            ServerPublicKeyCredentialCreationOptionsResponse result = apiInstance.getAttestationOptions(serverPublicKeyCredentialCreationOptionsRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Fido2OptionsServiceApi#getAttestationOptions");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ServerPublicKeyCredentialCreationOptionsRequest serverPublicKeyCredentialCreationOptionsRequest = new ServerPublicKeyCredentialCreationOptionsRequest(); // ServerPublicKeyCredentialCreationOptionsRequest | 

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

import org.openapitools.client.api.Fido2OptionsServiceApi;

public class Fido2OptionsServiceApiExample {
    public static void main(String[] args) {
        Fido2OptionsServiceApi apiInstance = new Fido2OptionsServiceApi();
        ServerPublicKeyCredentialCreationOptionsRequest serverPublicKeyCredentialCreationOptionsRequest = ; // ServerPublicKeyCredentialCreationOptionsRequest | 

        try {
            ServerPublicKeyCredentialCreationOptionsResponse result = apiInstance.getAttestationOptions(serverPublicKeyCredentialCreationOptionsRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Fido2OptionsServiceApi#getAttestationOptions");
            e.printStackTrace();
        }
    }
}

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

// FIDO2 options response
[apiInstance getAttestationOptionsWith:serverPublicKeyCredentialCreationOptionsRequest
              completionHandler: ^(ServerPublicKeyCredentialCreationOptionsResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisFidoRestApi = require('nevis_fido_rest_api');

// Create an instance of the API class
var api = new NevisFidoRestApi.Fido2OptionsServiceApi()
var serverPublicKeyCredentialCreationOptionsRequest = ; // {ServerPublicKeyCredentialCreationOptionsRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new Fido2OptionsServiceApi();
            var serverPublicKeyCredentialCreationOptionsRequest = new ServerPublicKeyCredentialCreationOptionsRequest(); // ServerPublicKeyCredentialCreationOptionsRequest | 

            try {
                // FIDO2 options response
                ServerPublicKeyCredentialCreationOptionsResponse result = apiInstance.getAttestationOptions(serverPublicKeyCredentialCreationOptionsRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling Fido2OptionsServiceApi.getAttestationOptions: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Fido2OptionsServiceApi();
$serverPublicKeyCredentialCreationOptionsRequest = ; // ServerPublicKeyCredentialCreationOptionsRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::Fido2OptionsServiceApi->new();
my $serverPublicKeyCredentialCreationOptionsRequest = WWW::OPenAPIClient::Object::ServerPublicKeyCredentialCreationOptionsRequest->new(); # ServerPublicKeyCredentialCreationOptionsRequest | 

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

try:
    # FIDO2 options response
    api_response = api_instance.get_attestation_options(serverPublicKeyCredentialCreationOptionsRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Fido2OptionsServiceApi->getAttestationOptions: %s\n" % e)

extern crate Fido2OptionsServiceApi;

pub fn main() {
    let serverPublicKeyCredentialCreationOptionsRequest = ; // ServerPublicKeyCredentialCreationOptionsRequest

    let mut context = Fido2OptionsServiceApi::Context::default();
    let result = client.getAttestationOptions(serverPublicKeyCredentialCreationOptionsRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        Fido2RegistrationServiceApi apiInstance = new Fido2RegistrationServiceApi();
        ServerPublicKeyCredentialForRegistration serverPublicKeyCredentialForRegistration = ; // ServerPublicKeyCredentialForRegistration | 

        try {
            ServerResponse result = apiInstance.submitAttestation(serverPublicKeyCredentialForRegistration);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Fido2RegistrationServiceApi#submitAttestation");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ServerPublicKeyCredentialForRegistration serverPublicKeyCredentialForRegistration = new ServerPublicKeyCredentialForRegistration(); // ServerPublicKeyCredentialForRegistration | 

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

import org.openapitools.client.api.Fido2RegistrationServiceApi;

public class Fido2RegistrationServiceApiExample {
    public static void main(String[] args) {
        Fido2RegistrationServiceApi apiInstance = new Fido2RegistrationServiceApi();
        ServerPublicKeyCredentialForRegistration serverPublicKeyCredentialForRegistration = ; // ServerPublicKeyCredentialForRegistration | 

        try {
            ServerResponse result = apiInstance.submitAttestation(serverPublicKeyCredentialForRegistration);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Fido2RegistrationServiceApi#submitAttestation");
            e.printStackTrace();
        }
    }
}

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

// WebAuthn registration ceremony endpoint
[apiInstance submitAttestationWith:serverPublicKeyCredentialForRegistration
              completionHandler: ^(ServerResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisFidoRestApi = require('nevis_fido_rest_api');

// Create an instance of the API class
var api = new NevisFidoRestApi.Fido2RegistrationServiceApi()
var serverPublicKeyCredentialForRegistration = ; // {ServerPublicKeyCredentialForRegistration} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new Fido2RegistrationServiceApi();
            var serverPublicKeyCredentialForRegistration = new ServerPublicKeyCredentialForRegistration(); // ServerPublicKeyCredentialForRegistration | 

            try {
                // WebAuthn registration ceremony endpoint
                ServerResponse result = apiInstance.submitAttestation(serverPublicKeyCredentialForRegistration);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling Fido2RegistrationServiceApi.submitAttestation: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Fido2RegistrationServiceApi();
$serverPublicKeyCredentialForRegistration = ; // ServerPublicKeyCredentialForRegistration | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::Fido2RegistrationServiceApi->new();
my $serverPublicKeyCredentialForRegistration = WWW::OPenAPIClient::Object::ServerPublicKeyCredentialForRegistration->new(); # ServerPublicKeyCredentialForRegistration | 

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

try:
    # WebAuthn registration ceremony endpoint
    api_response = api_instance.submit_attestation(serverPublicKeyCredentialForRegistration)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Fido2RegistrationServiceApi->submitAttestation: %s\n" % e)

extern crate Fido2RegistrationServiceApi;

pub fn main() {
    let serverPublicKeyCredentialForRegistration = ; // ServerPublicKeyCredentialForRegistration

    let mut context = Fido2RegistrationServiceApi::Context::default();
    let result = client.submitAttestation(serverPublicKeyCredentialForRegistration, &context).wait();

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

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

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

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

        // Create an instance of the API class
        Fido2StatusServiceApi apiInstance = new Fido2StatusServiceApi();
        StatusRequest statusRequest = ; // StatusRequest | 

        try {
            StatusResponse result = apiInstance.request4(statusRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Fido2StatusServiceApi#request4");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final StatusRequest statusRequest = new StatusRequest(); // StatusRequest | 

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

import org.openapitools.client.api.Fido2StatusServiceApi;

public class Fido2StatusServiceApiExample {
    public static void main(String[] args) {
        Fido2StatusServiceApi apiInstance = new Fido2StatusServiceApi();
        StatusRequest statusRequest = ; // StatusRequest | 

        try {
            StatusResponse result = apiInstance.request4(statusRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Fido2StatusServiceApi#request4");
            e.printStackTrace();
        }
    }
}

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

// Get FIDO2 ceremony status
[apiInstance request4With:statusRequest
              completionHandler: ^(StatusResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisFidoRestApi = require('nevis_fido_rest_api');

// Create an instance of the API class
var api = new NevisFidoRestApi.Fido2StatusServiceApi()
var statusRequest = ; // {StatusRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new Fido2StatusServiceApi();
            var statusRequest = new StatusRequest(); // StatusRequest | 

            try {
                // Get FIDO2 ceremony status
                StatusResponse result = apiInstance.request4(statusRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling Fido2StatusServiceApi.request4: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Fido2StatusServiceApi();
$statusRequest = ; // StatusRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::Fido2StatusServiceApi->new();
my $statusRequest = WWW::OPenAPIClient::Object::StatusRequest->new(); # StatusRequest | 

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

try:
    # Get FIDO2 ceremony status
    api_response = api_instance.request4(statusRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Fido2StatusServiceApi->request4: %s\n" % e)

extern crate Fido2StatusServiceApi;

pub fn main() {
    let statusRequest = ; // StatusRequest

    let mut context = Fido2StatusServiceApi::Context::default();
    let result = client.request4(statusRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FidoUAFDispatchTargetServiceApi apiInstance = new FidoUAFDispatchTargetServiceApi();
        CreateDispatchTargetRequest createDispatchTargetRequest = ; // CreateDispatchTargetRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreateDispatchTargetRequest createDispatchTargetRequest = new CreateDispatchTargetRequest(); // CreateDispatchTargetRequest | 

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

import org.openapitools.client.api.FidoUAFDispatchTargetServiceApi;

public class FidoUAFDispatchTargetServiceApiExample {
    public static void main(String[] args) {
        FidoUAFDispatchTargetServiceApi apiInstance = new FidoUAFDispatchTargetServiceApi();
        CreateDispatchTargetRequest createDispatchTargetRequest = ; // CreateDispatchTargetRequest | 

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

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

// Create a dispatch target
[apiInstance createWith:createDispatchTargetRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisFidoRestApi = require('nevis_fido_rest_api');

// Create an instance of the API class
var api = new NevisFidoRestApi.FidoUAFDispatchTargetServiceApi()
var createDispatchTargetRequest = ; // {CreateDispatchTargetRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FidoUAFDispatchTargetServiceApi();
            var createDispatchTargetRequest = new CreateDispatchTargetRequest(); // CreateDispatchTargetRequest | 

            try {
                // Create a dispatch target
                apiInstance.create(createDispatchTargetRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling FidoUAFDispatchTargetServiceApi.create: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FidoUAFDispatchTargetServiceApi();
$createDispatchTargetRequest = ; // CreateDispatchTargetRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FidoUAFDispatchTargetServiceApi->new();
my $createDispatchTargetRequest = WWW::OPenAPIClient::Object::CreateDispatchTargetRequest->new(); # CreateDispatchTargetRequest | 

eval {
    $api_instance->create(createDispatchTargetRequest => $createDispatchTargetRequest);
};
if ($@) {
    warn "Exception when calling FidoUAFDispatchTargetServiceApi->create: $@\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.FidoUAFDispatchTargetServiceApi()
createDispatchTargetRequest =  # CreateDispatchTargetRequest | 

try:
    # Create a dispatch target
    api_instance.create(createDispatchTargetRequest)
except ApiException as e:
    print("Exception when calling FidoUAFDispatchTargetServiceApi->create: %s\n" % e)

extern crate FidoUAFDispatchTargetServiceApi;

pub fn main() {
    let createDispatchTargetRequest = ; // CreateDispatchTargetRequest

    let mut context = FidoUAFDispatchTargetServiceApi::Context::default();
    let result = client.create(createDispatchTargetRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FidoUAFRequestServiceApi apiInstance = new FidoUAFRequestServiceApi();
        GetUafRequest getUafRequest = ; // GetUafRequest | 

        try {
            AuthenticationReturnUafRequest result = apiInstance.returnAuthenticationUafRequest(getUafRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFRequestServiceApi#returnAuthenticationUafRequest");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final GetUafRequest getUafRequest = new GetUafRequest(); // GetUafRequest | 

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

import org.openapitools.client.api.FidoUAFRequestServiceApi;

public class FidoUAFRequestServiceApiExample {
    public static void main(String[] args) {
        FidoUAFRequestServiceApi apiInstance = new FidoUAFRequestServiceApi();
        GetUafRequest getUafRequest = ; // GetUafRequest | 

        try {
            AuthenticationReturnUafRequest result = apiInstance.returnAuthenticationUafRequest(getUafRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFRequestServiceApi#returnAuthenticationUafRequest");
            e.printStackTrace();
        }
    }
}

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

// AuthenticationRequest service
[apiInstance returnAuthenticationUafRequestWith:getUafRequest
              completionHandler: ^(AuthenticationReturnUafRequest output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisFidoRestApi = require('nevis_fido_rest_api');

// Create an instance of the API class
var api = new NevisFidoRestApi.FidoUAFRequestServiceApi()
var getUafRequest = ; // {GetUafRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FidoUAFRequestServiceApi();
            var getUafRequest = new GetUafRequest(); // GetUafRequest | 

            try {
                // AuthenticationRequest service
                AuthenticationReturnUafRequest result = apiInstance.returnAuthenticationUafRequest(getUafRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FidoUAFRequestServiceApi.returnAuthenticationUafRequest: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FidoUAFRequestServiceApi();
$getUafRequest = ; // GetUafRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FidoUAFRequestServiceApi->new();
my $getUafRequest = WWW::OPenAPIClient::Object::GetUafRequest->new(); # GetUafRequest | 

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

try:
    # AuthenticationRequest service
    api_response = api_instance.return_authentication_uaf_request(getUafRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FidoUAFRequestServiceApi->returnAuthenticationUafRequest: %s\n" % e)

extern crate FidoUAFRequestServiceApi;

pub fn main() {
    let getUafRequest = ; // GetUafRequest

    let mut context = FidoUAFRequestServiceApi::Context::default();
    let result = client.returnAuthenticationUafRequest(getUafRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FidoUAFRequestServiceApi apiInstance = new FidoUAFRequestServiceApi();
        GetUafRequest getUafRequest = ; // GetUafRequest | 

        try {
            DeregistrationReturnUafRequest result = apiInstance.returnDeregistrationUafRequest(getUafRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFRequestServiceApi#returnDeregistrationUafRequest");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final GetUafRequest getUafRequest = new GetUafRequest(); // GetUafRequest | 

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

import org.openapitools.client.api.FidoUAFRequestServiceApi;

public class FidoUAFRequestServiceApiExample {
    public static void main(String[] args) {
        FidoUAFRequestServiceApi apiInstance = new FidoUAFRequestServiceApi();
        GetUafRequest getUafRequest = ; // GetUafRequest | 

        try {
            DeregistrationReturnUafRequest result = apiInstance.returnDeregistrationUafRequest(getUafRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFRequestServiceApi#returnDeregistrationUafRequest");
            e.printStackTrace();
        }
    }
}

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

// DeregistrationRequest service
[apiInstance returnDeregistrationUafRequestWith:getUafRequest
              completionHandler: ^(DeregistrationReturnUafRequest output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisFidoRestApi = require('nevis_fido_rest_api');

// Create an instance of the API class
var api = new NevisFidoRestApi.FidoUAFRequestServiceApi()
var getUafRequest = ; // {GetUafRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FidoUAFRequestServiceApi();
            var getUafRequest = new GetUafRequest(); // GetUafRequest | 

            try {
                // DeregistrationRequest service
                DeregistrationReturnUafRequest result = apiInstance.returnDeregistrationUafRequest(getUafRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FidoUAFRequestServiceApi.returnDeregistrationUafRequest: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FidoUAFRequestServiceApi();
$getUafRequest = ; // GetUafRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FidoUAFRequestServiceApi->new();
my $getUafRequest = WWW::OPenAPIClient::Object::GetUafRequest->new(); # GetUafRequest | 

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

try:
    # DeregistrationRequest service
    api_response = api_instance.return_deregistration_uaf_request(getUafRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FidoUAFRequestServiceApi->returnDeregistrationUafRequest: %s\n" % e)

extern crate FidoUAFRequestServiceApi;

pub fn main() {
    let getUafRequest = ; // GetUafRequest

    let mut context = FidoUAFRequestServiceApi::Context::default();
    let result = client.returnDeregistrationUafRequest(getUafRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FidoUAFRequestServiceApi apiInstance = new FidoUAFRequestServiceApi();
        GetUafRequest getUafRequest = ; // GetUafRequest | 

        try {
            RegistrationReturnUafRequest result = apiInstance.returnRegistrationUafRequest(getUafRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFRequestServiceApi#returnRegistrationUafRequest");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final GetUafRequest getUafRequest = new GetUafRequest(); // GetUafRequest | 

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

import org.openapitools.client.api.FidoUAFRequestServiceApi;

public class FidoUAFRequestServiceApiExample {
    public static void main(String[] args) {
        FidoUAFRequestServiceApi apiInstance = new FidoUAFRequestServiceApi();
        GetUafRequest getUafRequest = ; // GetUafRequest | 

        try {
            RegistrationReturnUafRequest result = apiInstance.returnRegistrationUafRequest(getUafRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFRequestServiceApi#returnRegistrationUafRequest");
            e.printStackTrace();
        }
    }
}

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

// RegistrationRequest service
[apiInstance returnRegistrationUafRequestWith:getUafRequest
              completionHandler: ^(RegistrationReturnUafRequest output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisFidoRestApi = require('nevis_fido_rest_api');

// Create an instance of the API class
var api = new NevisFidoRestApi.FidoUAFRequestServiceApi()
var getUafRequest = ; // {GetUafRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FidoUAFRequestServiceApi();
            var getUafRequest = new GetUafRequest(); // GetUafRequest | 

            try {
                // RegistrationRequest service
                RegistrationReturnUafRequest result = apiInstance.returnRegistrationUafRequest(getUafRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FidoUAFRequestServiceApi.returnRegistrationUafRequest: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FidoUAFRequestServiceApi();
$getUafRequest = ; // GetUafRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FidoUAFRequestServiceApi->new();
my $getUafRequest = WWW::OPenAPIClient::Object::GetUafRequest->new(); # GetUafRequest | 

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

try:
    # RegistrationRequest service
    api_response = api_instance.return_registration_uaf_request(getUafRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FidoUAFRequestServiceApi->returnRegistrationUafRequest: %s\n" % e)

extern crate FidoUAFRequestServiceApi;

pub fn main() {
    let getUafRequest = ; // GetUafRequest

    let mut context = FidoUAFRequestServiceApi::Context::default();
    let result = client.returnRegistrationUafRequest(getUafRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FidoUAFResponseServiceApi apiInstance = new FidoUAFResponseServiceApi();
        AuthenticationSendUafResponse authenticationSendUafResponse = ; // AuthenticationSendUafResponse | 

        try {
            ServerResponse result = apiInstance.authentication(authenticationSendUafResponse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFResponseServiceApi#authentication");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final AuthenticationSendUafResponse authenticationSendUafResponse = new AuthenticationSendUafResponse(); // AuthenticationSendUafResponse | 

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

import org.openapitools.client.api.FidoUAFResponseServiceApi;

public class FidoUAFResponseServiceApiExample {
    public static void main(String[] args) {
        FidoUAFResponseServiceApi apiInstance = new FidoUAFResponseServiceApi();
        AuthenticationSendUafResponse authenticationSendUafResponse = ; // AuthenticationSendUafResponse | 

        try {
            ServerResponse result = apiInstance.authentication(authenticationSendUafResponse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFResponseServiceApi#authentication");
            e.printStackTrace();
        }
    }
}

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

// Fido UAF authentication response service
[apiInstance authenticationWith:authenticationSendUafResponse
              completionHandler: ^(ServerResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisFidoRestApi = require('nevis_fido_rest_api');

// Create an instance of the API class
var api = new NevisFidoRestApi.FidoUAFResponseServiceApi()
var authenticationSendUafResponse = ; // {AuthenticationSendUafResponse} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FidoUAFResponseServiceApi();
            var authenticationSendUafResponse = new AuthenticationSendUafResponse(); // AuthenticationSendUafResponse | 

            try {
                // Fido UAF authentication response service
                ServerResponse result = apiInstance.authentication(authenticationSendUafResponse);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FidoUAFResponseServiceApi.authentication: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FidoUAFResponseServiceApi();
$authenticationSendUafResponse = ; // AuthenticationSendUafResponse | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FidoUAFResponseServiceApi->new();
my $authenticationSendUafResponse = WWW::OPenAPIClient::Object::AuthenticationSendUafResponse->new(); # AuthenticationSendUafResponse | 

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

try:
    # Fido UAF authentication response service
    api_response = api_instance.authentication(authenticationSendUafResponse)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FidoUAFResponseServiceApi->authentication: %s\n" % e)

extern crate FidoUAFResponseServiceApi;

pub fn main() {
    let authenticationSendUafResponse = ; // AuthenticationSendUafResponse

    let mut context = FidoUAFResponseServiceApi::Context::default();
    let result = client.authentication(authenticationSendUafResponse, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FidoUAFResponseServiceApi apiInstance = new FidoUAFResponseServiceApi();
        String userAgent = userAgent_example; // String | 
        RegistrationSendUafResponse registrationSendUafResponse = ; // RegistrationSendUafResponse | 

        try {
            ServerResponse result = apiInstance.registration(userAgent, registrationSendUafResponse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFResponseServiceApi#registration");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String userAgent = new String(); // String | 
final RegistrationSendUafResponse registrationSendUafResponse = new RegistrationSendUafResponse(); // RegistrationSendUafResponse | 

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

import org.openapitools.client.api.FidoUAFResponseServiceApi;

public class FidoUAFResponseServiceApiExample {
    public static void main(String[] args) {
        FidoUAFResponseServiceApi apiInstance = new FidoUAFResponseServiceApi();
        String userAgent = userAgent_example; // String | 
        RegistrationSendUafResponse registrationSendUafResponse = ; // RegistrationSendUafResponse | 

        try {
            ServerResponse result = apiInstance.registration(userAgent, registrationSendUafResponse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFResponseServiceApi#registration");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
FidoUAFResponseServiceApi *apiInstance = [[FidoUAFResponseServiceApi alloc] init];
String *userAgent = userAgent_example; //  (default to null)
RegistrationSendUafResponse *registrationSendUafResponse = ; // 

// Fido UAF registration response service
[apiInstance registrationWith:userAgent
    registrationSendUafResponse:registrationSendUafResponse
              completionHandler: ^(ServerResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisFidoRestApi = require('nevis_fido_rest_api');

// Create an instance of the API class
var api = new NevisFidoRestApi.FidoUAFResponseServiceApi()
var userAgent = userAgent_example; // {String} 
var registrationSendUafResponse = ; // {RegistrationSendUafResponse} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FidoUAFResponseServiceApi();
            var userAgent = userAgent_example;  // String |  (default to null)
            var registrationSendUafResponse = new RegistrationSendUafResponse(); // RegistrationSendUafResponse | 

            try {
                // Fido UAF registration response service
                ServerResponse result = apiInstance.registration(userAgent, registrationSendUafResponse);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FidoUAFResponseServiceApi.registration: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FidoUAFResponseServiceApi();
$userAgent = userAgent_example; // String | 
$registrationSendUafResponse = ; // RegistrationSendUafResponse | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FidoUAFResponseServiceApi->new();
my $userAgent = userAgent_example; # String | 
my $registrationSendUafResponse = WWW::OPenAPIClient::Object::RegistrationSendUafResponse->new(); # RegistrationSendUafResponse | 

eval {
    my $result = $api_instance->registration(userAgent => $userAgent, registrationSendUafResponse => $registrationSendUafResponse);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FidoUAFResponseServiceApi->registration: $@\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.FidoUAFResponseServiceApi()
userAgent = userAgent_example # String |  (default to null)
registrationSendUafResponse =  # RegistrationSendUafResponse | 

try:
    # Fido UAF registration response service
    api_response = api_instance.registration(userAgent, registrationSendUafResponse)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FidoUAFResponseServiceApi->registration: %s\n" % e)

extern crate FidoUAFResponseServiceApi;

pub fn main() {
    let userAgent = userAgent_example; // String
    let registrationSendUafResponse = ; // RegistrationSendUafResponse

    let mut context = FidoUAFResponseServiceApi::Context::default();
    let result = client.registration(userAgent, registrationSendUafResponse, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FidoUAFStatusServiceApi apiInstance = new FidoUAFStatusServiceApi();
        StatusRequest statusRequest = ; // StatusRequest | 

        try {
            StatusResponse result = apiInstance.request3(statusRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFStatusServiceApi#request3");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final StatusRequest statusRequest = new StatusRequest(); // StatusRequest | 

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

import org.openapitools.client.api.FidoUAFStatusServiceApi;

public class FidoUAFStatusServiceApiExample {
    public static void main(String[] args) {
        FidoUAFStatusServiceApi apiInstance = new FidoUAFStatusServiceApi();
        StatusRequest statusRequest = ; // StatusRequest | 

        try {
            StatusResponse result = apiInstance.request3(statusRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFStatusServiceApi#request3");
            e.printStackTrace();
        }
    }
}

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

// Get FIDO UAF operation status
[apiInstance request3With:statusRequest
              completionHandler: ^(StatusResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisFidoRestApi = require('nevis_fido_rest_api');

// Create an instance of the API class
var api = new NevisFidoRestApi.FidoUAFStatusServiceApi()
var statusRequest = ; // {StatusRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FidoUAFStatusServiceApi();
            var statusRequest = new StatusRequest(); // StatusRequest | 

            try {
                // Get FIDO UAF operation status
                StatusResponse result = apiInstance.request3(statusRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FidoUAFStatusServiceApi.request3: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FidoUAFStatusServiceApi();
$statusRequest = ; // StatusRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FidoUAFStatusServiceApi->new();
my $statusRequest = WWW::OPenAPIClient::Object::StatusRequest->new(); # StatusRequest | 

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

try:
    # Get FIDO UAF operation status
    api_response = api_instance.request3(statusRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FidoUAFStatusServiceApi->request3: %s\n" % e)

extern crate FidoUAFStatusServiceApi;

pub fn main() {
    let statusRequest = ; // StatusRequest

    let mut context = FidoUAFStatusServiceApi::Context::default();
    let result = client.request3(statusRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FidoUAFTokenServiceApi apiInstance = new FidoUAFTokenServiceApi();
        DispatchTokenRequest dispatchTokenRequest = ; // DispatchTokenRequest | 

        try {
            DispatchTokenResponse result = apiInstance.createAndDispatchToken(dispatchTokenRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFTokenServiceApi#createAndDispatchToken");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final DispatchTokenRequest dispatchTokenRequest = new DispatchTokenRequest(); // DispatchTokenRequest | 

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

import org.openapitools.client.api.FidoUAFTokenServiceApi;

public class FidoUAFTokenServiceApiExample {
    public static void main(String[] args) {
        FidoUAFTokenServiceApi apiInstance = new FidoUAFTokenServiceApi();
        DispatchTokenRequest dispatchTokenRequest = ; // DispatchTokenRequest | 

        try {
            DispatchTokenResponse result = apiInstance.createAndDispatchToken(dispatchTokenRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFTokenServiceApi#createAndDispatchToken");
            e.printStackTrace();
        }
    }
}

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

// Token dispatch endpoint
[apiInstance createAndDispatchTokenWith:dispatchTokenRequest
              completionHandler: ^(DispatchTokenResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisFidoRestApi = require('nevis_fido_rest_api');

// Create an instance of the API class
var api = new NevisFidoRestApi.FidoUAFTokenServiceApi()
var dispatchTokenRequest = ; // {DispatchTokenRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FidoUAFTokenServiceApi();
            var dispatchTokenRequest = new DispatchTokenRequest(); // DispatchTokenRequest | 

            try {
                // Token dispatch endpoint
                DispatchTokenResponse result = apiInstance.createAndDispatchToken(dispatchTokenRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FidoUAFTokenServiceApi.createAndDispatchToken: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FidoUAFTokenServiceApi();
$dispatchTokenRequest = ; // DispatchTokenRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FidoUAFTokenServiceApi->new();
my $dispatchTokenRequest = WWW::OPenAPIClient::Object::DispatchTokenRequest->new(); # DispatchTokenRequest | 

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

try:
    # Token dispatch endpoint
    api_response = api_instance.create_and_dispatch_token(dispatchTokenRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FidoUAFTokenServiceApi->createAndDispatchToken: %s\n" % e)

extern crate FidoUAFTokenServiceApi;

pub fn main() {
    let dispatchTokenRequest = ; // DispatchTokenRequest

    let mut context = FidoUAFTokenServiceApi::Context::default();
    let result = client.createAndDispatchToken(dispatchTokenRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FidoUAFTokenServiceApi apiInstance = new FidoUAFTokenServiceApi();
        DispatchTokenRequest dispatchTokenRequest = ; // DispatchTokenRequest | 

        try {
            DispatchTokenResponse result = apiInstance.createAndDispatchToken1(dispatchTokenRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFTokenServiceApi#createAndDispatchToken1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final DispatchTokenRequest dispatchTokenRequest = new DispatchTokenRequest(); // DispatchTokenRequest | 

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

import org.openapitools.client.api.FidoUAFTokenServiceApi;

public class FidoUAFTokenServiceApiExample {
    public static void main(String[] args) {
        FidoUAFTokenServiceApi apiInstance = new FidoUAFTokenServiceApi();
        DispatchTokenRequest dispatchTokenRequest = ; // DispatchTokenRequest | 

        try {
            DispatchTokenResponse result = apiInstance.createAndDispatchToken1(dispatchTokenRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFTokenServiceApi#createAndDispatchToken1");
            e.printStackTrace();
        }
    }
}

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

// Token dispatch endpoint
[apiInstance createAndDispatchToken1With:dispatchTokenRequest
              completionHandler: ^(DispatchTokenResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisFidoRestApi = require('nevis_fido_rest_api');

// Create an instance of the API class
var api = new NevisFidoRestApi.FidoUAFTokenServiceApi()
var dispatchTokenRequest = ; // {DispatchTokenRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FidoUAFTokenServiceApi();
            var dispatchTokenRequest = new DispatchTokenRequest(); // DispatchTokenRequest | 

            try {
                // Token dispatch endpoint
                DispatchTokenResponse result = apiInstance.createAndDispatchToken1(dispatchTokenRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FidoUAFTokenServiceApi.createAndDispatchToken1: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FidoUAFTokenServiceApi();
$dispatchTokenRequest = ; // DispatchTokenRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FidoUAFTokenServiceApi->new();
my $dispatchTokenRequest = WWW::OPenAPIClient::Object::DispatchTokenRequest->new(); # DispatchTokenRequest | 

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

try:
    # Token dispatch endpoint
    api_response = api_instance.create_and_dispatch_token1(dispatchTokenRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FidoUAFTokenServiceApi->createAndDispatchToken1: %s\n" % e)

extern crate FidoUAFTokenServiceApi;

pub fn main() {
    let dispatchTokenRequest = ; // DispatchTokenRequest

    let mut context = FidoUAFTokenServiceApi::Context::default();
    let result = client.createAndDispatchToken1(dispatchTokenRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FidoUAFTokenServiceApi apiInstance = new FidoUAFTokenServiceApi();
        DispatchTokenRequest dispatchTokenRequest = ; // DispatchTokenRequest | 

        try {
            DispatchTokenResponse result = apiInstance.createAndDispatchToken2(dispatchTokenRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFTokenServiceApi#createAndDispatchToken2");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final DispatchTokenRequest dispatchTokenRequest = new DispatchTokenRequest(); // DispatchTokenRequest | 

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

import org.openapitools.client.api.FidoUAFTokenServiceApi;

public class FidoUAFTokenServiceApiExample {
    public static void main(String[] args) {
        FidoUAFTokenServiceApi apiInstance = new FidoUAFTokenServiceApi();
        DispatchTokenRequest dispatchTokenRequest = ; // DispatchTokenRequest | 

        try {
            DispatchTokenResponse result = apiInstance.createAndDispatchToken2(dispatchTokenRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFTokenServiceApi#createAndDispatchToken2");
            e.printStackTrace();
        }
    }
}

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

// Token dispatch endpoint
[apiInstance createAndDispatchToken2With:dispatchTokenRequest
              completionHandler: ^(DispatchTokenResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisFidoRestApi = require('nevis_fido_rest_api');

// Create an instance of the API class
var api = new NevisFidoRestApi.FidoUAFTokenServiceApi()
var dispatchTokenRequest = ; // {DispatchTokenRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FidoUAFTokenServiceApi();
            var dispatchTokenRequest = new DispatchTokenRequest(); // DispatchTokenRequest | 

            try {
                // Token dispatch endpoint
                DispatchTokenResponse result = apiInstance.createAndDispatchToken2(dispatchTokenRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FidoUAFTokenServiceApi.createAndDispatchToken2: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FidoUAFTokenServiceApi();
$dispatchTokenRequest = ; // DispatchTokenRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FidoUAFTokenServiceApi->new();
my $dispatchTokenRequest = WWW::OPenAPIClient::Object::DispatchTokenRequest->new(); # DispatchTokenRequest | 

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

try:
    # Token dispatch endpoint
    api_response = api_instance.create_and_dispatch_token2(dispatchTokenRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FidoUAFTokenServiceApi->createAndDispatchToken2: %s\n" % e)

extern crate FidoUAFTokenServiceApi;

pub fn main() {
    let dispatchTokenRequest = ; // DispatchTokenRequest

    let mut context = FidoUAFTokenServiceApi::Context::default();
    let result = client.createAndDispatchToken2(dispatchTokenRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FidoUAFTokenServiceApi apiInstance = new FidoUAFTokenServiceApi();
        GetUafRequest getUafRequest = ; // GetUafRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final GetUafRequest getUafRequest = new GetUafRequest(); // GetUafRequest | 

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

import org.openapitools.client.api.FidoUAFTokenServiceApi;

public class FidoUAFTokenServiceApiExample {
    public static void main(String[] args) {
        FidoUAFTokenServiceApi apiInstance = new FidoUAFTokenServiceApi();
        GetUafRequest getUafRequest = ; // GetUafRequest | 

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

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

// Token creation endpoint
[apiInstance createTokenWith:getUafRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisFidoRestApi = require('nevis_fido_rest_api');

// Create an instance of the API class
var api = new NevisFidoRestApi.FidoUAFTokenServiceApi()
var getUafRequest = ; // {GetUafRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FidoUAFTokenServiceApi();
            var getUafRequest = new GetUafRequest(); // GetUafRequest | 

            try {
                // Token creation endpoint
                apiInstance.createToken(getUafRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling FidoUAFTokenServiceApi.createToken: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FidoUAFTokenServiceApi();
$getUafRequest = ; // GetUafRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FidoUAFTokenServiceApi->new();
my $getUafRequest = WWW::OPenAPIClient::Object::GetUafRequest->new(); # GetUafRequest | 

eval {
    $api_instance->createToken(getUafRequest => $getUafRequest);
};
if ($@) {
    warn "Exception when calling FidoUAFTokenServiceApi->createToken: $@\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.FidoUAFTokenServiceApi()
getUafRequest =  # GetUafRequest | 

try:
    # Token creation endpoint
    api_instance.create_token(getUafRequest)
except ApiException as e:
    print("Exception when calling FidoUAFTokenServiceApi->createToken: %s\n" % e)

extern crate FidoUAFTokenServiceApi;

pub fn main() {
    let getUafRequest = ; // GetUafRequest

    let mut context = FidoUAFTokenServiceApi::Context::default();
    let result = client.createToken(getUafRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FidoUAFTokenServiceApi apiInstance = new FidoUAFTokenServiceApi();
        GetUafRequest getUafRequest = ; // GetUafRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final GetUafRequest getUafRequest = new GetUafRequest(); // GetUafRequest | 

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

import org.openapitools.client.api.FidoUAFTokenServiceApi;

public class FidoUAFTokenServiceApiExample {
    public static void main(String[] args) {
        FidoUAFTokenServiceApi apiInstance = new FidoUAFTokenServiceApi();
        GetUafRequest getUafRequest = ; // GetUafRequest | 

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

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

// Token creation endpoint
[apiInstance createToken1With:getUafRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisFidoRestApi = require('nevis_fido_rest_api');

// Create an instance of the API class
var api = new NevisFidoRestApi.FidoUAFTokenServiceApi()
var getUafRequest = ; // {GetUafRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FidoUAFTokenServiceApi();
            var getUafRequest = new GetUafRequest(); // GetUafRequest | 

            try {
                // Token creation endpoint
                apiInstance.createToken1(getUafRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling FidoUAFTokenServiceApi.createToken1: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FidoUAFTokenServiceApi();
$getUafRequest = ; // GetUafRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FidoUAFTokenServiceApi->new();
my $getUafRequest = WWW::OPenAPIClient::Object::GetUafRequest->new(); # GetUafRequest | 

eval {
    $api_instance->createToken1(getUafRequest => $getUafRequest);
};
if ($@) {
    warn "Exception when calling FidoUAFTokenServiceApi->createToken1: $@\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.FidoUAFTokenServiceApi()
getUafRequest =  # GetUafRequest | 

try:
    # Token creation endpoint
    api_instance.create_token1(getUafRequest)
except ApiException as e:
    print("Exception when calling FidoUAFTokenServiceApi->createToken1: %s\n" % e)

extern crate FidoUAFTokenServiceApi;

pub fn main() {
    let getUafRequest = ; // GetUafRequest

    let mut context = FidoUAFTokenServiceApi::Context::default();
    let result = client.createToken1(getUafRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FidoUAFTokenServiceApi apiInstance = new FidoUAFTokenServiceApi();
        GetUafRequest getUafRequest = ; // GetUafRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final GetUafRequest getUafRequest = new GetUafRequest(); // GetUafRequest | 

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

import org.openapitools.client.api.FidoUAFTokenServiceApi;

public class FidoUAFTokenServiceApiExample {
    public static void main(String[] args) {
        FidoUAFTokenServiceApi apiInstance = new FidoUAFTokenServiceApi();
        GetUafRequest getUafRequest = ; // GetUafRequest | 

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

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

// Token creation endpoint
[apiInstance createToken2With:getUafRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisFidoRestApi = require('nevis_fido_rest_api');

// Create an instance of the API class
var api = new NevisFidoRestApi.FidoUAFTokenServiceApi()
var getUafRequest = ; // {GetUafRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FidoUAFTokenServiceApi();
            var getUafRequest = new GetUafRequest(); // GetUafRequest | 

            try {
                // Token creation endpoint
                apiInstance.createToken2(getUafRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling FidoUAFTokenServiceApi.createToken2: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FidoUAFTokenServiceApi();
$getUafRequest = ; // GetUafRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FidoUAFTokenServiceApi->new();
my $getUafRequest = WWW::OPenAPIClient::Object::GetUafRequest->new(); # GetUafRequest | 

eval {
    $api_instance->createToken2(getUafRequest => $getUafRequest);
};
if ($@) {
    warn "Exception when calling FidoUAFTokenServiceApi->createToken2: $@\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.FidoUAFTokenServiceApi()
getUafRequest =  # GetUafRequest | 

try:
    # Token creation endpoint
    api_instance.create_token2(getUafRequest)
except ApiException as e:
    print("Exception when calling FidoUAFTokenServiceApi->createToken2: %s\n" % e)

extern crate FidoUAFTokenServiceApi;

pub fn main() {
    let getUafRequest = ; // GetUafRequest

    let mut context = FidoUAFTokenServiceApi::Context::default();
    let result = client.createToken2(getUafRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FidoUAFTokenServiceApi apiInstance = new FidoUAFTokenServiceApi();
        RedeemTokenRequest redeemTokenRequest = ; // RedeemTokenRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final RedeemTokenRequest redeemTokenRequest = new RedeemTokenRequest(); // RedeemTokenRequest | 

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

import org.openapitools.client.api.FidoUAFTokenServiceApi;

public class FidoUAFTokenServiceApiExample {
    public static void main(String[] args) {
        FidoUAFTokenServiceApi apiInstance = new FidoUAFTokenServiceApi();
        RedeemTokenRequest redeemTokenRequest = ; // RedeemTokenRequest | 

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

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

// Token redemption endpoint
[apiInstance requestWith:redeemTokenRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisFidoRestApi = require('nevis_fido_rest_api');

// Create an instance of the API class
var api = new NevisFidoRestApi.FidoUAFTokenServiceApi()
var redeemTokenRequest = ; // {RedeemTokenRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FidoUAFTokenServiceApi();
            var redeemTokenRequest = new RedeemTokenRequest(); // RedeemTokenRequest | 

            try {
                // Token redemption endpoint
                apiInstance.request(redeemTokenRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling FidoUAFTokenServiceApi.request: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FidoUAFTokenServiceApi();
$redeemTokenRequest = ; // RedeemTokenRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FidoUAFTokenServiceApi->new();
my $redeemTokenRequest = WWW::OPenAPIClient::Object::RedeemTokenRequest->new(); # RedeemTokenRequest | 

eval {
    $api_instance->request(redeemTokenRequest => $redeemTokenRequest);
};
if ($@) {
    warn "Exception when calling FidoUAFTokenServiceApi->request: $@\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.FidoUAFTokenServiceApi()
redeemTokenRequest =  # RedeemTokenRequest | 

try:
    # Token redemption endpoint
    api_instance.request(redeemTokenRequest)
except ApiException as e:
    print("Exception when calling FidoUAFTokenServiceApi->request: %s\n" % e)

extern crate FidoUAFTokenServiceApi;

pub fn main() {
    let redeemTokenRequest = ; // RedeemTokenRequest

    let mut context = FidoUAFTokenServiceApi::Context::default();
    let result = client.request(redeemTokenRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FidoUAFTokenServiceApi apiInstance = new FidoUAFTokenServiceApi();
        RedeemTokenRequest redeemTokenRequest = ; // RedeemTokenRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final RedeemTokenRequest redeemTokenRequest = new RedeemTokenRequest(); // RedeemTokenRequest | 

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

import org.openapitools.client.api.FidoUAFTokenServiceApi;

public class FidoUAFTokenServiceApiExample {
    public static void main(String[] args) {
        FidoUAFTokenServiceApi apiInstance = new FidoUAFTokenServiceApi();
        RedeemTokenRequest redeemTokenRequest = ; // RedeemTokenRequest | 

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

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

// Token redemption endpoint
[apiInstance request1With:redeemTokenRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisFidoRestApi = require('nevis_fido_rest_api');

// Create an instance of the API class
var api = new NevisFidoRestApi.FidoUAFTokenServiceApi()
var redeemTokenRequest = ; // {RedeemTokenRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FidoUAFTokenServiceApi();
            var redeemTokenRequest = new RedeemTokenRequest(); // RedeemTokenRequest | 

            try {
                // Token redemption endpoint
                apiInstance.request1(redeemTokenRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling FidoUAFTokenServiceApi.request1: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FidoUAFTokenServiceApi();
$redeemTokenRequest = ; // RedeemTokenRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FidoUAFTokenServiceApi->new();
my $redeemTokenRequest = WWW::OPenAPIClient::Object::RedeemTokenRequest->new(); # RedeemTokenRequest | 

eval {
    $api_instance->request1(redeemTokenRequest => $redeemTokenRequest);
};
if ($@) {
    warn "Exception when calling FidoUAFTokenServiceApi->request1: $@\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.FidoUAFTokenServiceApi()
redeemTokenRequest =  # RedeemTokenRequest | 

try:
    # Token redemption endpoint
    api_instance.request1(redeemTokenRequest)
except ApiException as e:
    print("Exception when calling FidoUAFTokenServiceApi->request1: %s\n" % e)

extern crate FidoUAFTokenServiceApi;

pub fn main() {
    let redeemTokenRequest = ; // RedeemTokenRequest

    let mut context = FidoUAFTokenServiceApi::Context::default();
    let result = client.request1(redeemTokenRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FidoUAFTokenServiceApi apiInstance = new FidoUAFTokenServiceApi();
        RedeemTokenRequest redeemTokenRequest = ; // RedeemTokenRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final RedeemTokenRequest redeemTokenRequest = new RedeemTokenRequest(); // RedeemTokenRequest | 

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

import org.openapitools.client.api.FidoUAFTokenServiceApi;

public class FidoUAFTokenServiceApiExample {
    public static void main(String[] args) {
        FidoUAFTokenServiceApi apiInstance = new FidoUAFTokenServiceApi();
        RedeemTokenRequest redeemTokenRequest = ; // RedeemTokenRequest | 

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

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

// Token redemption endpoint
[apiInstance request2With:redeemTokenRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var NevisFidoRestApi = require('nevis_fido_rest_api');

// Create an instance of the API class
var api = new NevisFidoRestApi.FidoUAFTokenServiceApi()
var redeemTokenRequest = ; // {RedeemTokenRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FidoUAFTokenServiceApi();
            var redeemTokenRequest = new RedeemTokenRequest(); // RedeemTokenRequest | 

            try {
                // Token redemption endpoint
                apiInstance.request2(redeemTokenRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling FidoUAFTokenServiceApi.request2: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FidoUAFTokenServiceApi();
$redeemTokenRequest = ; // RedeemTokenRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FidoUAFTokenServiceApi->new();
my $redeemTokenRequest = WWW::OPenAPIClient::Object::RedeemTokenRequest->new(); # RedeemTokenRequest | 

eval {
    $api_instance->request2(redeemTokenRequest => $redeemTokenRequest);
};
if ($@) {
    warn "Exception when calling FidoUAFTokenServiceApi->request2: $@\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.FidoUAFTokenServiceApi()
redeemTokenRequest =  # RedeemTokenRequest | 

try:
    # Token redemption endpoint
    api_instance.request2(redeemTokenRequest)
except ApiException as e:
    print("Exception when calling FidoUAFTokenServiceApi->request2: %s\n" % e)

extern crate FidoUAFTokenServiceApi;

pub fn main() {
    let redeemTokenRequest = ; // RedeemTokenRequest

    let mut context = FidoUAFTokenServiceApi::Context::default();
    let result = client.request2(redeemTokenRequest, &context).wait();

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