nevisFIDO REST API

Fido2AuthenticationService

submitAssertion

WebAuthn authentication ceremony endpoint

Accepts the client's WebAuthn authentication assertion and performs server-side verification to authenticate the user.

/nevisfido/fido2/assertion/result

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://localhost:9080/nevisfido/fido2/assertion/result" \
 -d '{
  "response" : {
    "userHandle" : "userHandle",
    "clientDataJSON" : "clientDataJSON",
    "signature" : "signature",
    "authenticatorData" : "authenticatorData"
  },
  "userAgent" : "userAgent",
  "id" : "id",
  "type" : "type",
  "clientExtensionResults" : {
    "appidExclude" : true,
    "credProps" : {
      "rk" : true
    },
    "appid" : true,
    "uvm" : [ [ 0.8008281904610115, 0.8008281904610115 ], [ 0.8008281904610115, 0.8008281904610115 ] ],
    "hmacCreateSecret" : true,
    "hmacGetSecret" : {
      "output1" : "output1",
      "output2" : "output2"
    }
  }
}'

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);
}

Scopes

Parameters

Body parameters

Name	Description
serverPublicKeyCredentialForAuthentication *

Responses

Schema

Fido2OptionsService

getAssertionOptions

FIDO2 options response

Returns return an option to the client for the initiated WebAuthn authentication ceremony

/nevisfido/fido2/assertion/options

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://localhost:9080/nevisfido/fido2/assertion/options" \
 -d '{
  "extensions" : {
    "appidExclude" : "appidExclude",
    "credProps" : true,
    "enforceCredentialProtectionPolicy" : true,
    "appid" : "appid",
    "credentialProtectionPolicy" : "userVerificationOptional",
    "uvm" : true,
    "hmacCreateSecret" : true,
    "hmacGetSecret" : {
      "salt1" : "salt1",
      "salt2" : "salt2"
    }
  },
  "userVerification" : "userVerification",
  "username" : "username"
}'

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);
}

Scopes

Parameters

Body parameters

Name	Description
serverPublicKeyCredentialGetOptionsRequest *	Authentication request example

Responses

Schema

getAttestationOptions

FIDO2 options response

Returns return an option to the client for the initiated registration WebAuthn ceremony

/nevisfido/fido2/attestation/options

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://localhost:9080/nevisfido/fido2/attestation/options" \
 -d '{
  "extensions" : {
    "appidExclude" : "appidExclude",
    "credProps" : true,
    "enforceCredentialProtectionPolicy" : true,
    "appid" : "appid",
    "credentialProtectionPolicy" : "userVerificationOptional",
    "uvm" : true,
    "hmacCreateSecret" : true,
    "hmacGetSecret" : {
      "salt1" : "salt1",
      "salt2" : "salt2"
    }
  },
  "attestation" : "attestation",
  "displayName" : "displayName",
  "authenticatorSelection" : {
    "authenticatorAttachment" : "authenticatorAttachment",
    "userVerification" : "userVerification",
    "requireResidentKey" : true,
    "residentKey" : "residentKey"
  },
  "username" : "username"
}'

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);
}

Scopes

Parameters

Body parameters

Name	Description
serverPublicKeyCredentialCreationOptionsRequest *	Registration request example

Responses

Schema

Fido2RegistrationService

submitAttestation

WebAuthn registration ceremony endpoint

Receives the client's WebAuthn attestation response and performs server-side verification to register a new authenticator for the user.

/nevisfido/fido2/attestation/result

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://localhost:9080/nevisfido/fido2/attestation/result" \
 -d '{
  "response" : {
    "clientDataJSON" : "clientDataJSON",
    "attestationObject" : "attestationObject"
  },
  "userFriendlyName" : "userFriendlyName",
  "userAgent" : "userAgent",
  "id" : "id",
  "type" : "type",
  "clientExtensionResults" : {
    "appidExclude" : true,
    "credProps" : {
      "rk" : true
    },
    "appid" : true,
    "uvm" : [ [ 0.8008281904610115, 0.8008281904610115 ], [ 0.8008281904610115, 0.8008281904610115 ] ],
    "hmacCreateSecret" : true,
    "hmacGetSecret" : {
      "output1" : "output1",
      "output2" : "output2"
    }
  }
}'

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);
}

Scopes

Parameters

Body parameters

Name	Description
serverPublicKeyCredentialForRegistration *

Responses

Schema

Fido2StatusService

request4

Get FIDO2 ceremony status

Returns the status of a previously initiated FIDO2 ceremony.

/nevisfido/fido2/status

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:9080/nevisfido/fido2/status" \
 -d '{
  "sessionId" : "sessionId"
}'

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);
}

Scopes

Parameters

Body parameters

Name	Description
statusRequest *

Responses

Schema

FidoUAFDeviceService

delete1

Delete device credential

This endpoint's purpose is delete the information of the device associated with the provided identifier.

/nevisfido/devices/credentials/{deviceId}

Usage and SDK Samples

curl -X DELETE \
 "http://localhost:9080/nevisfido/devices/credentials/{deviceId}"

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

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

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

        // Create an instance of the API class
        FidoUAFDeviceServiceApi apiInstance = new FidoUAFDeviceServiceApi();
        String deviceId = deviceId_example; // String | 
        String deviceSignature = deviceSignature_example; // String | 

        try {
            apiInstance.delete1(deviceId, deviceSignature);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFDeviceServiceApi#delete1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String deviceId = new String(); // String | 
final String deviceSignature = new String(); // String | 

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

import org.openapitools.client.api.FidoUAFDeviceServiceApi;

public class FidoUAFDeviceServiceApiExample {
    public static void main(String[] args) {
        FidoUAFDeviceServiceApi apiInstance = new FidoUAFDeviceServiceApi();
        String deviceId = deviceId_example; // String | 
        String deviceSignature = deviceSignature_example; // String | 

        try {
            apiInstance.delete1(deviceId, deviceSignature);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFDeviceServiceApi#delete1");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
FidoUAFDeviceServiceApi *apiInstance = [[FidoUAFDeviceServiceApi alloc] init];
String *deviceId = deviceId_example; //  (default to null)
String *deviceSignature = deviceSignature_example; //  (default to null)

// Delete device credential
[apiInstance delete1With:deviceId
    deviceSignature:deviceSignature
              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.FidoUAFDeviceServiceApi()
var deviceId = deviceId_example; // {String} 
var deviceSignature = deviceSignature_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FidoUAFDeviceServiceApi();
            var deviceId = deviceId_example;  // String |  (default to null)
            var deviceSignature = deviceSignature_example;  // String |  (default to null)

            try {
                // Delete device credential
                apiInstance.delete1(deviceId, deviceSignature);
            } catch (Exception e) {
                Debug.Print("Exception when calling FidoUAFDeviceServiceApi.delete1: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FidoUAFDeviceServiceApi();
$deviceId = deviceId_example; // String | 
$deviceSignature = deviceSignature_example; // String | 

try {
    $api_instance->delete1($deviceId, $deviceSignature);
} catch (Exception $e) {
    echo 'Exception when calling FidoUAFDeviceServiceApi->delete1: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FidoUAFDeviceServiceApi->new();
my $deviceId = deviceId_example; # String | 
my $deviceSignature = deviceSignature_example; # String | 

eval {
    $api_instance->delete1(deviceId => $deviceId, deviceSignature => $deviceSignature);
};
if ($@) {
    warn "Exception when calling FidoUAFDeviceServiceApi->delete1: $@\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.FidoUAFDeviceServiceApi()
deviceId = deviceId_example # String |  (default to null)
deviceSignature = deviceSignature_example # String |  (default to null)

try:
    # Delete device credential
    api_instance.delete1(deviceId, deviceSignature)
except ApiException as e:
    print("Exception when calling FidoUAFDeviceServiceApi->delete1: %s\n" % e)

extern crate FidoUAFDeviceServiceApi;

pub fn main() {
    let deviceId = deviceId_example; // String
    let deviceSignature = deviceSignature_example; // String

    let mut context = FidoUAFDeviceServiceApi::Context::default();
    let result = client.delete1(deviceId, deviceSignature, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
deviceId*	String Required

Header parameters

Name	Description
Device-Signature*	String Required

Responses

get

Get Get Device Out-of-Band Operations

This endpoint's purpose is to list the non-redeemed out-of-band operations of a device.

/nevisfido/devices/oobOperations/{deviceId}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/jose;charset=UTF-8" \
 "http://localhost:9080/nevisfido/devices/oobOperations/{deviceId}"

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

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

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

        // Create an instance of the API class
        FidoUAFDeviceServiceApi apiInstance = new FidoUAFDeviceServiceApi();
        String deviceId = deviceId_example; // String | 
        String deviceSignature = deviceSignature_example; // String | 

        try {
            'String' result = apiInstance.get(deviceId, deviceSignature);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFDeviceServiceApi#get");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String deviceId = new String(); // String | 
final String deviceSignature = new String(); // String | 

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

import org.openapitools.client.api.FidoUAFDeviceServiceApi;

public class FidoUAFDeviceServiceApiExample {
    public static void main(String[] args) {
        FidoUAFDeviceServiceApi apiInstance = new FidoUAFDeviceServiceApi();
        String deviceId = deviceId_example; // String | 
        String deviceSignature = deviceSignature_example; // String | 

        try {
            'String' result = apiInstance.get(deviceId, deviceSignature);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFDeviceServiceApi#get");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
FidoUAFDeviceServiceApi *apiInstance = [[FidoUAFDeviceServiceApi alloc] init];
String *deviceId = deviceId_example; //  (default to null)
String *deviceSignature = deviceSignature_example; //  (default to null)

// Get Get Device Out-of-Band Operations
[apiInstance getWith:deviceId
    deviceSignature:deviceSignature
              completionHandler: ^('String' 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.FidoUAFDeviceServiceApi()
var deviceId = deviceId_example; // {String} 
var deviceSignature = deviceSignature_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FidoUAFDeviceServiceApi();
            var deviceId = deviceId_example;  // String |  (default to null)
            var deviceSignature = deviceSignature_example;  // String |  (default to null)

            try {
                // Get Get Device Out-of-Band Operations
                'String' result = apiInstance.get(deviceId, deviceSignature);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FidoUAFDeviceServiceApi.get: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FidoUAFDeviceServiceApi();
$deviceId = deviceId_example; // String | 
$deviceSignature = deviceSignature_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FidoUAFDeviceServiceApi->new();
my $deviceId = deviceId_example; # String | 
my $deviceSignature = deviceSignature_example; # String | 

eval {
    my $result = $api_instance->get(deviceId => $deviceId, deviceSignature => $deviceSignature);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FidoUAFDeviceServiceApi->get: $@\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.FidoUAFDeviceServiceApi()
deviceId = deviceId_example # String |  (default to null)
deviceSignature = deviceSignature_example # String |  (default to null)

try:
    # Get Get Device Out-of-Band Operations
    api_response = api_instance.get(deviceId, deviceSignature)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FidoUAFDeviceServiceApi->get: %s\n" % e)

extern crate FidoUAFDeviceServiceApi;

pub fn main() {
    let deviceId = deviceId_example; // String
    let deviceSignature = deviceSignature_example; // String

    let mut context = FidoUAFDeviceServiceApi::Context::default();
    let result = client.get(deviceId, deviceSignature, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
deviceId*	String Required

Header parameters

Name	Description
Device-Signature*	String Required

Responses

Schema

get1

Get device credential

This endpoint's purpose is to list the information of a device (FIDO UAF credentials and dispatch targets).

/nevisfido/devices/credentials/{deviceId}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/jose;charset=UTF-8" \
 "http://localhost:9080/nevisfido/devices/credentials/{deviceId}"

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

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

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

        // Create an instance of the API class
        FidoUAFDeviceServiceApi apiInstance = new FidoUAFDeviceServiceApi();
        String deviceId = deviceId_example; // String | 
        String deviceSignature = deviceSignature_example; // String | 

        try {
            'String' result = apiInstance.get1(deviceId, deviceSignature);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFDeviceServiceApi#get1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String deviceId = new String(); // String | 
final String deviceSignature = new String(); // String | 

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

import org.openapitools.client.api.FidoUAFDeviceServiceApi;

public class FidoUAFDeviceServiceApiExample {
    public static void main(String[] args) {
        FidoUAFDeviceServiceApi apiInstance = new FidoUAFDeviceServiceApi();
        String deviceId = deviceId_example; // String | 
        String deviceSignature = deviceSignature_example; // String | 

        try {
            'String' result = apiInstance.get1(deviceId, deviceSignature);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFDeviceServiceApi#get1");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
FidoUAFDeviceServiceApi *apiInstance = [[FidoUAFDeviceServiceApi alloc] init];
String *deviceId = deviceId_example; //  (default to null)
String *deviceSignature = deviceSignature_example; //  (default to null)

// Get device credential
[apiInstance get1With:deviceId
    deviceSignature:deviceSignature
              completionHandler: ^('String' 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.FidoUAFDeviceServiceApi()
var deviceId = deviceId_example; // {String} 
var deviceSignature = deviceSignature_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FidoUAFDeviceServiceApi();
            var deviceId = deviceId_example;  // String |  (default to null)
            var deviceSignature = deviceSignature_example;  // String |  (default to null)

            try {
                // Get device credential
                'String' result = apiInstance.get1(deviceId, deviceSignature);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FidoUAFDeviceServiceApi.get1: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FidoUAFDeviceServiceApi();
$deviceId = deviceId_example; // String | 
$deviceSignature = deviceSignature_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FidoUAFDeviceServiceApi->new();
my $deviceId = deviceId_example; # String | 
my $deviceSignature = deviceSignature_example; # String | 

eval {
    my $result = $api_instance->get1(deviceId => $deviceId, deviceSignature => $deviceSignature);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FidoUAFDeviceServiceApi->get1: $@\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.FidoUAFDeviceServiceApi()
deviceId = deviceId_example # String |  (default to null)
deviceSignature = deviceSignature_example # String |  (default to null)

try:
    # Get device credential
    api_response = api_instance.get1(deviceId, deviceSignature)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FidoUAFDeviceServiceApi->get1: %s\n" % e)

extern crate FidoUAFDeviceServiceApi;

pub fn main() {
    let deviceId = deviceId_example; // String
    let deviceSignature = deviceSignature_example; // String

    let mut context = FidoUAFDeviceServiceApi::Context::default();
    let result = client.get1(deviceId, deviceSignature, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
deviceId*	String Required

Header parameters

Name	Description
Device-Signature*	String Required

Responses

Schema

modify1

Modify device credential

This endpoint's purpose is to modify the information of a device.

/nevisfido/devices/credentials/{id}

Usage and SDK Samples

curl -X PATCH \
 -H "Content-Type: application/jose;charset=UTF-8" \
 "http://localhost:9080/nevisfido/devices/credentials/{id}" \
 -d 'Custom MIME type example not yet supported: application/jose;charset=UTF-8'

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

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

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

        // Create an instance of the API class
        FidoUAFDeviceServiceApi apiInstance = new FidoUAFDeviceServiceApi();
        String id = id_example; // String | 
        String userAgent = userAgent_example; // String | 
        String body = body_example; // String | 

        try {
            apiInstance.modify1(id, userAgent, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFDeviceServiceApi#modify1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 
final String userAgent = new String(); // String | 
final String body = new String(); // String | 

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

import org.openapitools.client.api.FidoUAFDeviceServiceApi;

public class FidoUAFDeviceServiceApiExample {
    public static void main(String[] args) {
        FidoUAFDeviceServiceApi apiInstance = new FidoUAFDeviceServiceApi();
        String id = id_example; // String | 
        String userAgent = userAgent_example; // String | 
        String body = body_example; // String | 

        try {
            apiInstance.modify1(id, userAgent, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFDeviceServiceApi#modify1");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
FidoUAFDeviceServiceApi *apiInstance = [[FidoUAFDeviceServiceApi alloc] init];
String *id = id_example; //  (default to null)
String *userAgent = userAgent_example; //  (default to null)
String *body = body_example; // 

// Modify device credential
[apiInstance modify1With:id
    userAgent:userAgent
    body:body
              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.FidoUAFDeviceServiceApi()
var id = id_example; // {String} 
var userAgent = userAgent_example; // {String} 
var body = body_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FidoUAFDeviceServiceApi();
            var id = id_example;  // String |  (default to null)
            var userAgent = userAgent_example;  // String |  (default to null)
            var body = body_example;  // String | 

            try {
                // Modify device credential
                apiInstance.modify1(id, userAgent, body);
            } catch (Exception e) {
                Debug.Print("Exception when calling FidoUAFDeviceServiceApi.modify1: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FidoUAFDeviceServiceApi();
$id = id_example; // String | 
$userAgent = userAgent_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->modify1($id, $userAgent, $body);
} catch (Exception $e) {
    echo 'Exception when calling FidoUAFDeviceServiceApi->modify1: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FidoUAFDeviceServiceApi->new();
my $id = id_example; # String | 
my $userAgent = userAgent_example; # String | 
my $body = WWW::OPenAPIClient::Object::String->new(); # String | 

eval {
    $api_instance->modify1(id => $id, userAgent => $userAgent, body => $body);
};
if ($@) {
    warn "Exception when calling FidoUAFDeviceServiceApi->modify1: $@\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.FidoUAFDeviceServiceApi()
id = id_example # String |  (default to null)
userAgent = userAgent_example # String |  (default to null)
body = body_example # String | 

try:
    # Modify device credential
    api_instance.modify1(id, userAgent, body)
except ApiException as e:
    print("Exception when calling FidoUAFDeviceServiceApi->modify1: %s\n" % e)

extern crate FidoUAFDeviceServiceApi;

pub fn main() {
    let id = id_example; // String
    let userAgent = userAgent_example; // String
    let body = body_example; // String

    let mut context = FidoUAFDeviceServiceApi::Context::default();
    let result = client.modify1(id, userAgent, body, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	String Required

Header parameters

Name	Description
User-Agent*	String Required

Body parameters

Name	Description
body *

Responses

FidoUAFDispatchTargetService

create

Create a dispatch target

/nevisfido/token/dispatch/targets

Usage and SDK Samples

curl -X POST \
 -H "Content-Type: application/json" \
 "http://localhost:9080/nevisfido/token/dispatch/targets" \
 -d '{
  "signatureKey" : "signatureKey",
  "name" : "name",
  "encryptionKey" : "encryptionKey",
  "deviceId" : "deviceId",
  "dispatcher" : "dispatcher",
  "username" : "username",
  "target" : "target"
}'

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);
}

Scopes

Parameters

Body parameters

Name	Description
createDispatchTargetRequest *

Responses

delete

Delete a dispatch target

/nevisfido/token/dispatch/targets/{id}

Usage and SDK Samples

curl -X DELETE \
 "http://localhost:9080/nevisfido/token/dispatch/targets/{id}"

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();
        String id = id_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 

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

import org.openapitools.client.api.FidoUAFDispatchTargetServiceApi;

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

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



// Create an instance of the API class
FidoUAFDispatchTargetServiceApi *apiInstance = [[FidoUAFDispatchTargetServiceApi alloc] init];
String *id = id_example; //  (default to null)

// Delete a dispatch target
[apiInstance deleteWith:id
              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 id = id_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FidoUAFDispatchTargetServiceApi();
            var id = id_example;  // String |  (default to null)

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

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

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

try {
    $api_instance->delete($id);
} catch (Exception $e) {
    echo 'Exception when calling FidoUAFDispatchTargetServiceApi->delete: ', $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 $id = id_example; # String | 

eval {
    $api_instance->delete(id => $id);
};
if ($@) {
    warn "Exception when calling FidoUAFDispatchTargetServiceApi->delete: $@\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()
id = id_example # String |  (default to null)

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

extern crate FidoUAFDispatchTargetServiceApi;

pub fn main() {
    let id = id_example; // String

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	String Required

Responses

modify

Modify a dispatch target

/nevisfido/token/dispatch/targets/{id}

Usage and SDK Samples

curl -X PATCH \
 -H "Content-Type: application/jose;charset=UTF-8" \
 "http://localhost:9080/nevisfido/token/dispatch/targets/{id}" \
 -d 'Custom MIME type example not yet supported: application/jose;charset=UTF-8'

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();
        String id = id_example; // String | 
        String userAgent = userAgent_example; // String | 
        String body = body_example; // String | 

        try {
            apiInstance.modify(id, userAgent, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFDispatchTargetServiceApi#modify");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | 
final String userAgent = new String(); // String | 
final String body = new String(); // String | 

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

import org.openapitools.client.api.FidoUAFDispatchTargetServiceApi;

public class FidoUAFDispatchTargetServiceApiExample {
    public static void main(String[] args) {
        FidoUAFDispatchTargetServiceApi apiInstance = new FidoUAFDispatchTargetServiceApi();
        String id = id_example; // String | 
        String userAgent = userAgent_example; // String | 
        String body = body_example; // String | 

        try {
            apiInstance.modify(id, userAgent, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFDispatchTargetServiceApi#modify");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
FidoUAFDispatchTargetServiceApi *apiInstance = [[FidoUAFDispatchTargetServiceApi alloc] init];
String *id = id_example; //  (default to null)
String *userAgent = userAgent_example; //  (default to null)
String *body = body_example; // 

// Modify a dispatch target
[apiInstance modifyWith:id
    userAgent:userAgent
    body:body
              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 id = id_example; // {String} 
var userAgent = userAgent_example; // {String} 
var body = body_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new FidoUAFDispatchTargetServiceApi();
            var id = id_example;  // String |  (default to null)
            var userAgent = userAgent_example;  // String |  (default to null)
            var body = body_example;  // String | 

            try {
                // Modify a dispatch target
                apiInstance.modify(id, userAgent, body);
            } catch (Exception e) {
                Debug.Print("Exception when calling FidoUAFDispatchTargetServiceApi.modify: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FidoUAFDispatchTargetServiceApi();
$id = id_example; // String | 
$userAgent = userAgent_example; // String | 
$body = body_example; // String | 

try {
    $api_instance->modify($id, $userAgent, $body);
} catch (Exception $e) {
    echo 'Exception when calling FidoUAFDispatchTargetServiceApi->modify: ', $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 $id = id_example; # String | 
my $userAgent = userAgent_example; # String | 
my $body = WWW::OPenAPIClient::Object::String->new(); # String | 

eval {
    $api_instance->modify(id => $id, userAgent => $userAgent, body => $body);
};
if ($@) {
    warn "Exception when calling FidoUAFDispatchTargetServiceApi->modify: $@\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()
id = id_example # String |  (default to null)
userAgent = userAgent_example # String |  (default to null)
body = body_example # String | 

try:
    # Modify a dispatch target
    api_instance.modify(id, userAgent, body)
except ApiException as e:
    print("Exception when calling FidoUAFDispatchTargetServiceApi->modify: %s\n" % e)

extern crate FidoUAFDispatchTargetServiceApi;

pub fn main() {
    let id = id_example; // String
    let userAgent = userAgent_example; // String
    let body = body_example; // String

    let mut context = FidoUAFDispatchTargetServiceApi::Context::default();
    let result = client.modify(id, userAgent, body, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	String Required

Header parameters

Name	Description
User-Agent*	String Required

Body parameters

Name	Description
body *

Responses

query

Query a dispatch target

/nevisfido/token/dispatch/targets

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:9080/nevisfido/token/dispatch/targets?username=username_example"

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();
        String username = username_example; // String | 

        try {
            DispatchTargets result = apiInstance.query(username);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFDispatchTargetServiceApi#query");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String username = new String(); // String | 

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

import org.openapitools.client.api.FidoUAFDispatchTargetServiceApi;

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

        try {
            DispatchTargets result = apiInstance.query(username);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFDispatchTargetServiceApi#query");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
FidoUAFDispatchTargetServiceApi *apiInstance = [[FidoUAFDispatchTargetServiceApi alloc] init];
String *username = username_example; //  (optional) (default to null)

// Query a dispatch target
[apiInstance queryWith:username
              completionHandler: ^(DispatchTargets 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.FidoUAFDispatchTargetServiceApi()
var opts = {
  'username': username_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new FidoUAFDispatchTargetServiceApi();
            var username = username_example;  // String |  (optional)  (default to null)

            try {
                // Query a dispatch target
                DispatchTargets result = apiInstance.query(username);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FidoUAFDispatchTargetServiceApi.query: " + e.Message );
            }
        }
    }
}

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

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

try {
    $result = $api_instance->query($username);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FidoUAFDispatchTargetServiceApi->query: ', $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 $username = username_example; # String | 

eval {
    my $result = $api_instance->query(username => $username);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FidoUAFDispatchTargetServiceApi->query: $@\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()
username = username_example # String |  (optional) (default to null)

try:
    # Query a dispatch target
    api_response = api_instance.query(username=username)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FidoUAFDispatchTargetServiceApi->query: %s\n" % e)

extern crate FidoUAFDispatchTargetServiceApi;

pub fn main() {
    let username = username_example; // String

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

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

Scopes

Parameters

Query parameters

Name	Description
username	String

Responses

Schema

FidoUAFFacets

getFacets

Get trusted facets

Returns the list of trusted application facets accepted by the FIDO server.

/nevisfido/uaf/1.1/facets

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/fido.trusted-apps+json" \
 "http://localhost:9080/nevisfido/uaf/1.1/facets"

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

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

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

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

        try {
            TrustedFacetsList result = apiInstance.getFacets();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFFacetsApi#getFacets");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.FidoUAFFacetsApi;

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

        try {
            TrustedFacetsList result = apiInstance.getFacets();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FidoUAFFacetsApi#getFacets");
            e.printStackTrace();
        }
    }
}



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

// Get trusted facets
[apiInstance getFacetsWithCompletionHandler: 
              ^(TrustedFacetsList 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.FidoUAFFacetsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getFacets(callback);

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

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

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

            try {
                // Get trusted facets
                TrustedFacetsList result = apiInstance.getFacets();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FidoUAFFacetsApi.getFacets: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get trusted facets
    api_response = api_instance.get_facets()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FidoUAFFacetsApi->getFacets: %s\n" % e)

extern crate FidoUAFFacetsApi;

pub fn main() {

    let mut context = FidoUAFFacetsApi::Context::default();
    let result = client.getFacets(&context).wait();

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

Scopes

Parameters

Responses

Schema

FidoUAFRequestService

returnAuthenticationUafRequest

AuthenticationRequest service

Returns an AuthenticationRequest to the UAF client

/nevisfido/uaf/1.1/request/authentication

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/fido+uaf;charset=UTF-8" \
 -H "Content-Type: application/fido+uaf;charset=UTF-8" \
 "http://localhost:9080/nevisfido/uaf/1.1/request/authentication" \
 -d 'Custom MIME type example not yet supported: application/fido+uaf;charset=UTF-8'

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);
}

Scopes

Parameters

Body parameters

Name	Description
getUafRequest *

Responses

Schema

returnDeregistrationUafRequest

DeregistrationRequest service

Returns a DeregistrationRequest to the UAF client

/nevisfido/uaf/1.1/request/deregistration

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/fido+uaf;charset=UTF-8" \
 -H "Content-Type: application/fido+uaf;charset=UTF-8" \
 "http://localhost:9080/nevisfido/uaf/1.1/request/deregistration" \
 -d 'Custom MIME type example not yet supported: application/fido+uaf;charset=UTF-8'

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);
}

Scopes

Parameters

Body parameters

Name	Description
getUafRequest *

Responses

Schema

returnRegistrationUafRequest

RegistrationRequest service

Returns a RegistrationRequest to the UAF client

/nevisfido/uaf/1.1/request/registration

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/fido+uaf;charset=UTF-8" \
 -H "Content-Type: application/fido+uaf;charset=UTF-8" \
 "http://localhost:9080/nevisfido/uaf/1.1/request/registration" \
 -d 'Custom MIME type example not yet supported: application/fido+uaf;charset=UTF-8'

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);
}

Scopes

Parameters

Body parameters

Name	Description
getUafRequest *

Responses

Schema

FidoUAFResponseService

authentication

Fido UAF authentication response service

The FIDO Client submits the `AuthenticationResponse` to the FIDO Server, as a response to the previously issued `AuthenticationRequest`.

/nevisfido/uaf/1.1/authentication

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/fido+uaf;charset=UTF-8" \
 -H "Content-Type: application/fido+uaf;charset=UTF-8" \
 "http://localhost:9080/nevisfido/uaf/1.1/authentication" \
 -d 'Custom MIME type example not yet supported: application/fido+uaf;charset=UTF-8'

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);
}

Scopes

Parameters

Body parameters

Name	Description
authenticationSendUafResponse *

Responses

Schema

registration

Fido UAF registration response service

The FIDO Client submits the `RegistrationResponse` to the FIDO Server, as a response to the previously issued `RegistrationRequest`.

/nevisfido/uaf/1.1/registration

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/fido+uaf;charset=UTF-8" \
 -H "Content-Type: application/fido+uaf;charset=UTF-8" \
 "http://localhost:9080/nevisfido/uaf/1.1/registration" \
 -d 'Custom MIME type example not yet supported: application/fido+uaf;charset=UTF-8'

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);
}

Scopes

Parameters

Header parameters

Name	Description
User-Agent*	String Required

Body parameters

Name	Description
registrationSendUafResponse *

Responses

Schema

FidoUAFStatusService

request3

Get FIDO UAF operation status

Returns the status of a previously initiated UAF operation.

/nevisfido/status

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:9080/nevisfido/status" \
 -d '{
  "sessionId" : "sessionId"
}'

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);
}

Scopes

Parameters

Body parameters

Name	Description
statusRequest *

Responses

Schema

FidoUAFTokenService

createAndDispatchToken

Token dispatch endpoint

The Dispatch Token Service requires from the FIDO client a JSON payload with a `GetUAFRequest` object as defined in the [FIDO UAF HTTP Transport Specification](https://fidoalliance.org/specs/fido-uaf-v1.1-ps-20170202/fido-uaf-client-api-transport-v1.1-ps-20170202.html#getuafrequest-dictionary). This `GetUAFRequest` object is used to initiate the given FIDO operation after the redemption of the token, a `ReturnUafRequest` will be returned for the redeemer party.

/nevisfido/token/dispatch/deregistration

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:9080/nevisfido/token/dispatch/deregistration" \
 -d '{
  "dispatchTargetId" : "dispatchTargetId",
  "getUafRequest" : {
    "op" : "Reg",
    "context" : "",
    "previousRequest" : "previousRequest"
  },
  "dispatcher" : "dispatcher",
  "dispatchInformation" : "dispatchInformation"
}'

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);
}

Scopes

Parameters

Body parameters

Name	Description
dispatchTokenRequest *

Responses

Schema

createAndDispatchToken1

Token dispatch endpoint

/nevisfido/token/dispatch/authentication

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:9080/nevisfido/token/dispatch/authentication" \
 -d '{
  "dispatchTargetId" : "dispatchTargetId",
  "getUafRequest" : {
    "op" : "Reg",
    "context" : "",
    "previousRequest" : "previousRequest"
  },
  "dispatcher" : "dispatcher",
  "dispatchInformation" : "dispatchInformation"
}'

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);
}

Scopes

Parameters

Body parameters

Name	Description
dispatchTokenRequest *

Responses

Schema

createAndDispatchToken2

Token dispatch endpoint

/nevisfido/token/dispatch/registration

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:9080/nevisfido/token/dispatch/registration" \
 -d '{
  "dispatchTargetId" : "dispatchTargetId",
  "getUafRequest" : {
    "op" : "Reg",
    "context" : "",
    "previousRequest" : "previousRequest"
  },
  "dispatcher" : "dispatcher",
  "dispatchInformation" : "dispatchInformation"
}'

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);
}

Scopes

Parameters

Body parameters

Name	Description
dispatchTokenRequest *

Responses

Schema

createToken

Token creation endpoint

The Create Token Service requires a JSON payload with a `GetUAFRequest` object as defined in the [FIDO UAF HTTP Transport Specification](https://fidoalliance.org/specs/fido-uaf-v1.1-ps-20170202/fido-uaf-client-api-transport-v1.1-ps-20170202.html#getuafrequest-dictionary).

/nevisfido/token/create/authentication

Usage and SDK Samples

curl -X POST \
 -H "Content-Type: application/fido+uaf;charset=UTF-8" \
 "http://localhost:9080/nevisfido/token/create/authentication" \
 -d 'Custom MIME type example not yet supported: application/fido+uaf;charset=UTF-8'

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);
}

Scopes

Parameters

Body parameters

Name	Description
getUafRequest *

Responses

createToken1

Token creation endpoint

/nevisfido/token/create/registration

Usage and SDK Samples

curl -X POST \
 -H "Content-Type: application/fido+uaf;charset=UTF-8" \
 "http://localhost:9080/nevisfido/token/create/registration" \
 -d 'Custom MIME type example not yet supported: application/fido+uaf;charset=UTF-8'

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);
}

Scopes

Parameters

Body parameters

Name	Description
getUafRequest *

Responses

createToken2

Token creation endpoint

/nevisfido/token/create/deregistration

Usage and SDK Samples

curl -X POST \
 -H "Content-Type: application/fido+uaf;charset=UTF-8" \
 "http://localhost:9080/nevisfido/token/create/deregistration" \
 -d 'Custom MIME type example not yet supported: application/fido+uaf;charset=UTF-8'

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);
}

Scopes

Parameters

Body parameters

Name	Description
getUafRequest *

Responses

request

Token redemption endpoint

To trigger the registration, authentication or deregistration process, the Redeem Token Service requires a request body with a JSON payload containing a token (in the token attribute).

/nevisfido/token/redeem/deregistration

Usage and SDK Samples

curl -X POST \
 -H "Content-Type: application/json" \
 "http://localhost:9080/nevisfido/token/redeem/deregistration" \
 -d '{
  "token" : "token"
}'

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);
}

Scopes

Parameters

Body parameters

Name	Description
redeemTokenRequest *

Responses

request1

Token redemption endpoint

To trigger the registration, authentication or deregistration process, the Redeem Token Service requires a request body with a JSON payload containing a token (in the token attribute).

/nevisfido/token/redeem/registration

Usage and SDK Samples

curl -X POST \
 -H "Content-Type: application/json" \
 "http://localhost:9080/nevisfido/token/redeem/registration" \
 -d '{
  "token" : "token"
}'

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);
}

Scopes

Parameters

Body parameters

Name	Description
redeemTokenRequest *

Responses

request2

Token redemption endpoint

To trigger the registration, authentication or deregistration process, the Redeem Token Service requires a request body with a JSON payload containing a token (in the token attribute).

/nevisfido/token/redeem/authentication

Usage and SDK Samples

curl -X POST \
 -H "Content-Type: application/json" \
 "http://localhost:9080/nevisfido/token/redeem/authentication" \
 -d '{
  "token" : "token"
}'

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);
}

Scopes

Parameters

Body parameters

Name	Description
redeemTokenRequest *