Secure Notes API

AuthenticationAPIs

login

User Login

Login with email and password to receive JWT token


/auth/login

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: */*"\
-H "Content-Type: application/json"\
"http://localhost:8080/auth/login"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthenticationAPIsApi;

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

public class AuthenticationAPIsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        AuthenticationAPIsApi apiInstance = new AuthenticationAPIsApi();
        LoginRequest body = ; // LoginRequest | 
        try {
            LoginResponse result = apiInstance.login(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthenticationAPIsApi#login");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AuthenticationAPIsApi;

public class AuthenticationAPIsApiExample {

    public static void main(String[] args) {
        AuthenticationAPIsApi apiInstance = new AuthenticationAPIsApi();
        LoginRequest body = ; // LoginRequest | 
        try {
            LoginResponse result = apiInstance.login(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthenticationAPIsApi#login");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
LoginRequest *body = ; // 

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

// User Login
[apiInstance loginWith:body
              completionHandler: ^(LoginResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SecureNotesApi = require('secure_notes_api');
var defaultClient = SecureNotesApi.ApiClient.instance;


var api = new SecureNotesApi.AuthenticationAPIsApi()
var body = ; // {{LoginRequest}} 

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

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

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


            var apiInstance = new AuthenticationAPIsApi();
            var body = new LoginRequest(); // LoginRequest | 

            try
            {
                // User Login
                LoginResponse result = apiInstance.login(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuthenticationAPIsApi.login: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAuthenticationAPIsApi();
$body = ; // LoginRequest | 

try {
    $result = $api_instance->login($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthenticationAPIsApi->login: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AuthenticationAPIsApi;


my $api_instance = WWW::SwaggerClient::AuthenticationAPIsApi->new();
my $body = WWW::SwaggerClient::Object::LoginRequest->new(); # LoginRequest | 

eval { 
    my $result = $api_instance->login(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthenticationAPIsApi->login: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.AuthenticationAPIsApi()
body =  # LoginRequest | 

try: 
    # User Login
    api_response = api_instance.login(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthenticationAPIsApi->login: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - OK

preRegister

Initiate Registration

Send OTP to user's email for pre-registration


/auth/pre-register

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: */*"\
-H "Content-Type: application/json"\
"http://localhost:8080/auth/pre-register"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthenticationAPIsApi;

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

public class AuthenticationAPIsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        AuthenticationAPIsApi apiInstance = new AuthenticationAPIsApi();
        PreRegisterRequest body = ; // PreRegisterRequest | 
        try {
            ApiResponse result = apiInstance.preRegister(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthenticationAPIsApi#preRegister");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AuthenticationAPIsApi;

public class AuthenticationAPIsApiExample {

    public static void main(String[] args) {
        AuthenticationAPIsApi apiInstance = new AuthenticationAPIsApi();
        PreRegisterRequest body = ; // PreRegisterRequest | 
        try {
            ApiResponse result = apiInstance.preRegister(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthenticationAPIsApi#preRegister");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
PreRegisterRequest *body = ; // 

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

// Initiate Registration
[apiInstance preRegisterWith:body
              completionHandler: ^(ApiResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SecureNotesApi = require('secure_notes_api');
var defaultClient = SecureNotesApi.ApiClient.instance;


var api = new SecureNotesApi.AuthenticationAPIsApi()
var body = ; // {{PreRegisterRequest}} 

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

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

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


            var apiInstance = new AuthenticationAPIsApi();
            var body = new PreRegisterRequest(); // PreRegisterRequest | 

            try
            {
                // Initiate Registration
                ApiResponse result = apiInstance.preRegister(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuthenticationAPIsApi.preRegister: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAuthenticationAPIsApi();
$body = ; // PreRegisterRequest | 

try {
    $result = $api_instance->preRegister($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthenticationAPIsApi->preRegister: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AuthenticationAPIsApi;


my $api_instance = WWW::SwaggerClient::AuthenticationAPIsApi->new();
my $body = WWW::SwaggerClient::Object::PreRegisterRequest->new(); # PreRegisterRequest | 

eval { 
    my $result = $api_instance->preRegister(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthenticationAPIsApi->preRegister: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.AuthenticationAPIsApi()
body =  # PreRegisterRequest | 

try: 
    # Initiate Registration
    api_response = api_instance.pre_register(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthenticationAPIsApi->preRegister: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - OK

register

Register User

Register a new user after OTP verification


/auth/register

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: */*"\
-H "Content-Type: application/json"\
"http://localhost:8080/auth/register"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthenticationAPIsApi;

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

public class AuthenticationAPIsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        AuthenticationAPIsApi apiInstance = new AuthenticationAPIsApi();
        RegisterRequest body = ; // RegisterRequest | 
        try {
            ApiResponse result = apiInstance.register(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthenticationAPIsApi#register");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AuthenticationAPIsApi;

public class AuthenticationAPIsApiExample {

    public static void main(String[] args) {
        AuthenticationAPIsApi apiInstance = new AuthenticationAPIsApi();
        RegisterRequest body = ; // RegisterRequest | 
        try {
            ApiResponse result = apiInstance.register(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthenticationAPIsApi#register");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
RegisterRequest *body = ; // 

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

// Register User
[apiInstance registerWith:body
              completionHandler: ^(ApiResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SecureNotesApi = require('secure_notes_api');
var defaultClient = SecureNotesApi.ApiClient.instance;


var api = new SecureNotesApi.AuthenticationAPIsApi()
var body = ; // {{RegisterRequest}} 

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

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

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


            var apiInstance = new AuthenticationAPIsApi();
            var body = new RegisterRequest(); // RegisterRequest | 

            try
            {
                // Register User
                ApiResponse result = apiInstance.register(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuthenticationAPIsApi.register: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAuthenticationAPIsApi();
$body = ; // RegisterRequest | 

try {
    $result = $api_instance->register($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthenticationAPIsApi->register: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AuthenticationAPIsApi;


my $api_instance = WWW::SwaggerClient::AuthenticationAPIsApi->new();
my $body = WWW::SwaggerClient::Object::RegisterRequest->new(); # RegisterRequest | 

eval { 
    my $result = $api_instance->register(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthenticationAPIsApi->register: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.AuthenticationAPIsApi()
body =  # RegisterRequest | 

try: 
    # Register User
    api_response = api_instance.register(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthenticationAPIsApi->register: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - OK

resetPassword

Reset Password

Reset password using token


/auth/reset-password

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: */*"\
-H "Content-Type: application/json"\
"http://localhost:8080/auth/reset-password"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthenticationAPIsApi;

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

public class AuthenticationAPIsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        AuthenticationAPIsApi apiInstance = new AuthenticationAPIsApi();
        ResetPasswordRequest body = ; // ResetPasswordRequest | 
        try {
            ResetPasswordResponse result = apiInstance.resetPassword(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthenticationAPIsApi#resetPassword");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AuthenticationAPIsApi;

public class AuthenticationAPIsApiExample {

    public static void main(String[] args) {
        AuthenticationAPIsApi apiInstance = new AuthenticationAPIsApi();
        ResetPasswordRequest body = ; // ResetPasswordRequest | 
        try {
            ResetPasswordResponse result = apiInstance.resetPassword(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthenticationAPIsApi#resetPassword");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
ResetPasswordRequest *body = ; // 

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

// Reset Password
[apiInstance resetPasswordWith:body
              completionHandler: ^(ResetPasswordResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SecureNotesApi = require('secure_notes_api');
var defaultClient = SecureNotesApi.ApiClient.instance;


var api = new SecureNotesApi.AuthenticationAPIsApi()
var body = ; // {{ResetPasswordRequest}} 

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

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

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


            var apiInstance = new AuthenticationAPIsApi();
            var body = new ResetPasswordRequest(); // ResetPasswordRequest | 

            try
            {
                // Reset Password
                ResetPasswordResponse result = apiInstance.resetPassword(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuthenticationAPIsApi.resetPassword: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAuthenticationAPIsApi();
$body = ; // ResetPasswordRequest | 

try {
    $result = $api_instance->resetPassword($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthenticationAPIsApi->resetPassword: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AuthenticationAPIsApi;


my $api_instance = WWW::SwaggerClient::AuthenticationAPIsApi->new();
my $body = WWW::SwaggerClient::Object::ResetPasswordRequest->new(); # ResetPasswordRequest | 

eval { 
    my $result = $api_instance->resetPassword(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthenticationAPIsApi->resetPassword: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.AuthenticationAPIsApi()
body =  # ResetPasswordRequest | 

try: 
    # Reset Password
    api_response = api_instance.reset_password(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthenticationAPIsApi->resetPassword: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - OK

resetPasswordRequest

Forgot Password

Send password reset link to registered email


/auth/forgot-password

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: */*"\
-H "Content-Type: application/json"\
"http://localhost:8080/auth/forgot-password"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthenticationAPIsApi;

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

public class AuthenticationAPIsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        AuthenticationAPIsApi apiInstance = new AuthenticationAPIsApi();
        ForgotPasswordRequest body = ; // ForgotPasswordRequest | 
        try {
            ForgotPasswordResponse result = apiInstance.resetPasswordRequest(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthenticationAPIsApi#resetPasswordRequest");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AuthenticationAPIsApi;

public class AuthenticationAPIsApiExample {

    public static void main(String[] args) {
        AuthenticationAPIsApi apiInstance = new AuthenticationAPIsApi();
        ForgotPasswordRequest body = ; // ForgotPasswordRequest | 
        try {
            ForgotPasswordResponse result = apiInstance.resetPasswordRequest(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthenticationAPIsApi#resetPasswordRequest");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
ForgotPasswordRequest *body = ; // 

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

// Forgot Password
[apiInstance resetPasswordRequestWith:body
              completionHandler: ^(ForgotPasswordResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SecureNotesApi = require('secure_notes_api');
var defaultClient = SecureNotesApi.ApiClient.instance;


var api = new SecureNotesApi.AuthenticationAPIsApi()
var body = ; // {{ForgotPasswordRequest}} 

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

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

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


            var apiInstance = new AuthenticationAPIsApi();
            var body = new ForgotPasswordRequest(); // ForgotPasswordRequest | 

            try
            {
                // Forgot Password
                ForgotPasswordResponse result = apiInstance.resetPasswordRequest(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuthenticationAPIsApi.resetPasswordRequest: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAuthenticationAPIsApi();
$body = ; // ForgotPasswordRequest | 

try {
    $result = $api_instance->resetPasswordRequest($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthenticationAPIsApi->resetPasswordRequest: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AuthenticationAPIsApi;


my $api_instance = WWW::SwaggerClient::AuthenticationAPIsApi->new();
my $body = WWW::SwaggerClient::Object::ForgotPasswordRequest->new(); # ForgotPasswordRequest | 

eval { 
    my $result = $api_instance->resetPasswordRequest(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthenticationAPIsApi->resetPasswordRequest: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.AuthenticationAPIsApi()
body =  # ForgotPasswordRequest | 

try: 
    # Forgot Password
    api_response = api_instance.reset_password_request(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthenticationAPIsApi->resetPasswordRequest: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - OK

verifyOtp

Verify OTP

Verify OTP sent to user's email


/auth/verify-otp

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: */*"\
-H "Content-Type: application/json"\
"http://localhost:8080/auth/verify-otp"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthenticationAPIsApi;

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

public class AuthenticationAPIsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        AuthenticationAPIsApi apiInstance = new AuthenticationAPIsApi();
        VerifyOtpRequest body = ; // VerifyOtpRequest | 
        try {
            ApiResponse result = apiInstance.verifyOtp(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthenticationAPIsApi#verifyOtp");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AuthenticationAPIsApi;

public class AuthenticationAPIsApiExample {

    public static void main(String[] args) {
        AuthenticationAPIsApi apiInstance = new AuthenticationAPIsApi();
        VerifyOtpRequest body = ; // VerifyOtpRequest | 
        try {
            ApiResponse result = apiInstance.verifyOtp(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthenticationAPIsApi#verifyOtp");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
VerifyOtpRequest *body = ; // 

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

// Verify OTP
[apiInstance verifyOtpWith:body
              completionHandler: ^(ApiResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SecureNotesApi = require('secure_notes_api');
var defaultClient = SecureNotesApi.ApiClient.instance;


var api = new SecureNotesApi.AuthenticationAPIsApi()
var body = ; // {{VerifyOtpRequest}} 

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

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

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


            var apiInstance = new AuthenticationAPIsApi();
            var body = new VerifyOtpRequest(); // VerifyOtpRequest | 

            try
            {
                // Verify OTP
                ApiResponse result = apiInstance.verifyOtp(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuthenticationAPIsApi.verifyOtp: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAuthenticationAPIsApi();
$body = ; // VerifyOtpRequest | 

try {
    $result = $api_instance->verifyOtp($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthenticationAPIsApi->verifyOtp: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AuthenticationAPIsApi;


my $api_instance = WWW::SwaggerClient::AuthenticationAPIsApi->new();
my $body = WWW::SwaggerClient::Object::VerifyOtpRequest->new(); # VerifyOtpRequest | 

eval { 
    my $result = $api_instance->verifyOtp(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthenticationAPIsApi->verifyOtp: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.AuthenticationAPIsApi()
body =  # VerifyOtpRequest | 

try: 
    # Verify OTP
    api_response = api_instance.verify_otp(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthenticationAPIsApi->verifyOtp: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - OK

Notes

addNote

Add or update a note

Saves a new note if it doesn't exist or updates it if already present for the authenticated user


/add-notes

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: */*"\
-H "Content-Type: application/json"\
"http://localhost:8080/add-notes"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NotesApi;

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

public class NotesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        NotesApi apiInstance = new NotesApi();
        NoteRequest body = ; // NoteRequest | 
        try {
            apiInstance.addNote(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotesApi#addNote");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.NotesApi;

public class NotesApiExample {

    public static void main(String[] args) {
        NotesApi apiInstance = new NotesApi();
        NoteRequest body = ; // NoteRequest | 
        try {
            apiInstance.addNote(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotesApi#addNote");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
NoteRequest *body = ; // 

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

// Add or update a note
[apiInstance addNoteWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SecureNotesApi = require('secure_notes_api');
var defaultClient = SecureNotesApi.ApiClient.instance;


var api = new SecureNotesApi.NotesApi()
var body = ; // {{NoteRequest}} 

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

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

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


            var apiInstance = new NotesApi();
            var body = new NoteRequest(); // NoteRequest | 

            try
            {
                // Add or update a note
                apiInstance.addNote(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NotesApi.addNote: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiNotesApi();
$body = ; // NoteRequest | 

try {
    $api_instance->addNote($body);
} catch (Exception $e) {
    echo 'Exception when calling NotesApi->addNote: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NotesApi;


my $api_instance = WWW::SwaggerClient::NotesApi->new();
my $body = WWW::SwaggerClient::Object::NoteRequest->new(); # NoteRequest | 

eval { 
    $api_instance->addNote(body => $body);
};
if ($@) {
    warn "Exception when calling NotesApi->addNote: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.NotesApi()
body =  # NoteRequest | 

try: 
    # Add or update a note
    api_instance.add_note(body)
except ApiException as e:
    print("Exception when calling NotesApi->addNote: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - OK

deleteNote

Delete note by ID

Deletes a specific note if it exists and belongs to the authenticated user


/delete-note/{id}

Usage and SDK Samples

curl -X DELETE\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: */*"\
"http://localhost:8080/delete-note/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NotesApi;

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

public class NotesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        NotesApi apiInstance = new NotesApi();
         id = ; //  | 
        try {
            apiInstance.deleteNote(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotesApi#deleteNote");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.NotesApi;

public class NotesApiExample {

    public static void main(String[] args) {
        NotesApi apiInstance = new NotesApi();
         id = ; //  | 
        try {
            apiInstance.deleteNote(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotesApi#deleteNote");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
 *id = ; // 

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

// Delete note by ID
[apiInstance deleteNoteWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SecureNotesApi = require('secure_notes_api');
var defaultClient = SecureNotesApi.ApiClient.instance;


var api = new SecureNotesApi.NotesApi()
var id = ; // {{}} 

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

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

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


            var apiInstance = new NotesApi();
            var id = new (); //  | 

            try
            {
                // Delete note by ID
                apiInstance.deleteNote(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NotesApi.deleteNote: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiNotesApi();
$id = ; //  | 

try {
    $api_instance->deleteNote($id);
} catch (Exception $e) {
    echo 'Exception when calling NotesApi->deleteNote: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NotesApi;


my $api_instance = WWW::SwaggerClient::NotesApi->new();
my $id = ; #  | 

eval { 
    $api_instance->deleteNote(id => $id);
};
if ($@) {
    warn "Exception when calling NotesApi->deleteNote: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.NotesApi()
id =  #  | 

try: 
    # Delete note by ID
    api_instance.delete_note(id)
except ApiException as e:
    print("Exception when calling NotesApi->deleteNote: %s\n" % e)

Parameters

Path parameters
Name Description
id*
(int64)
Required

Responses

Status: 200 - OK

getAllNotes

Get all notes

Returns all notes belonging to the authenticated user


/view-notes

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: */*"\
"http://localhost:8080/view-notes"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NotesApi;

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

public class NotesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        NotesApi apiInstance = new NotesApi();
        try {
            apiInstance.getAllNotes();
        } catch (ApiException e) {
            System.err.println("Exception when calling NotesApi#getAllNotes");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.NotesApi;

public class NotesApiExample {

    public static void main(String[] args) {
        NotesApi apiInstance = new NotesApi();
        try {
            apiInstance.getAllNotes();
        } catch (ApiException e) {
            System.err.println("Exception when calling NotesApi#getAllNotes");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Get all notes
[apiInstance getAllNotesWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SecureNotesApi = require('secure_notes_api');
var defaultClient = SecureNotesApi.ApiClient.instance;


var api = new SecureNotesApi.NotesApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.getAllNotes(callback);

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

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


            var apiInstance = new NotesApi();

            try
            {
                // Get all notes
                apiInstance.getAllNotes();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NotesApi.getAllNotes: " + e.Message );
            }
        }
    }
}

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


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

try {
    $api_instance->getAllNotes();
} catch (Exception $e) {
    echo 'Exception when calling NotesApi->getAllNotes: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NotesApi;


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

eval { 
    $api_instance->getAllNotes();
};
if ($@) {
    warn "Exception when calling NotesApi->getAllNotes: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


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

try: 
    # Get all notes
    api_instance.get_all_notes()
except ApiException as e:
    print("Exception when calling NotesApi->getAllNotes: %s\n" % e)

Parameters

Responses

Status: 200 - OK

updateNote

Update note by ID

Updates the content or title of a specific note belonging to the authenticated user


/update-note/{id}

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: */*"\
-H "Content-Type: application/json"\
"http://localhost:8080/update-note/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NotesApi;

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

public class NotesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        NotesApi apiInstance = new NotesApi();
        NoteRequest body = ; // NoteRequest | 
         id = ; //  | 
        try {
            apiInstance.updateNote(body, id);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotesApi#updateNote");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.NotesApi;

public class NotesApiExample {

    public static void main(String[] args) {
        NotesApi apiInstance = new NotesApi();
        NoteRequest body = ; // NoteRequest | 
         id = ; //  | 
        try {
            apiInstance.updateNote(body, id);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotesApi#updateNote");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
NoteRequest *body = ; // 
 *id = ; // 

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

// Update note by ID
[apiInstance updateNoteWith:body
    id:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SecureNotesApi = require('secure_notes_api');
var defaultClient = SecureNotesApi.ApiClient.instance;


var api = new SecureNotesApi.NotesApi()
var body = ; // {{NoteRequest}} 
var id = ; // {{}} 

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

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

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


            var apiInstance = new NotesApi();
            var body = new NoteRequest(); // NoteRequest | 
            var id = new (); //  | 

            try
            {
                // Update note by ID
                apiInstance.updateNote(body, id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NotesApi.updateNote: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiNotesApi();
$body = ; // NoteRequest | 
$id = ; //  | 

try {
    $api_instance->updateNote($body, $id);
} catch (Exception $e) {
    echo 'Exception when calling NotesApi->updateNote: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NotesApi;


my $api_instance = WWW::SwaggerClient::NotesApi->new();
my $body = WWW::SwaggerClient::Object::NoteRequest->new(); # NoteRequest | 
my $id = ; #  | 

eval { 
    $api_instance->updateNote(body => $body, id => $id);
};
if ($@) {
    warn "Exception when calling NotesApi->updateNote: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.NotesApi()
body =  # NoteRequest | 
id =  #  | 

try: 
    # Update note by ID
    api_instance.update_note(body, id)
except ApiException as e:
    print("Exception when calling NotesApi->updateNote: %s\n" % e)

Parameters

Path parameters
Name Description
id*
(int64)
Required
Body parameters
Name Description
body *

Responses

Status: 200 - OK

User

deleteAccount

Delete user account

Deletes the account of the currently authenticated user


/delete-account

Usage and SDK Samples

curl -X DELETE\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: */*"\
"http://localhost:8080/delete-account"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UserApi;

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

public class UserApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        UserApi apiInstance = new UserApi();
        try {
            apiInstance.deleteAccount();
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#deleteAccount");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.UserApi;

public class UserApiExample {

    public static void main(String[] args) {
        UserApi apiInstance = new UserApi();
        try {
            apiInstance.deleteAccount();
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#deleteAccount");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Delete user account
[apiInstance deleteAccountWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SecureNotesApi = require('secure_notes_api');
var defaultClient = SecureNotesApi.ApiClient.instance;


var api = new SecureNotesApi.UserApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteAccount(callback);

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

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


            var apiInstance = new UserApi();

            try
            {
                // Delete user account
                apiInstance.deleteAccount();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.deleteAccount: " + e.Message );
            }
        }
    }
}

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


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

try {
    $api_instance->deleteAccount();
} catch (Exception $e) {
    echo 'Exception when calling UserApi->deleteAccount: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UserApi;


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

eval { 
    $api_instance->deleteAccount();
};
if ($@) {
    warn "Exception when calling UserApi->deleteAccount: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


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

try: 
    # Delete user account
    api_instance.delete_account()
except ApiException as e:
    print("Exception when calling UserApi->deleteAccount: %s\n" % e)

Parameters

Responses

Status: 200 - OK

getMyProfileInfo

Get user profile

Returns the profile information (username, email, auth provider) of the authenticated user


/profile

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: */*"\
"http://localhost:8080/profile"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UserApi;

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

public class UserApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        UserApi apiInstance = new UserApi();
        try {
            UserProfileInfo result = apiInstance.getMyProfileInfo();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#getMyProfileInfo");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.UserApi;

public class UserApiExample {

    public static void main(String[] args) {
        UserApi apiInstance = new UserApi();
        try {
            UserProfileInfo result = apiInstance.getMyProfileInfo();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#getMyProfileInfo");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Get user profile
[apiInstance getMyProfileInfoWithCompletionHandler: 
              ^(UserProfileInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SecureNotesApi = require('secure_notes_api');
var defaultClient = SecureNotesApi.ApiClient.instance;


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

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

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


            var apiInstance = new UserApi();

            try
            {
                // Get user profile
                UserProfileInfo result = apiInstance.getMyProfileInfo();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UserApi.getMyProfileInfo: " + e.Message );
            }
        }
    }
}

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


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

try {
    $result = $api_instance->getMyProfileInfo();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserApi->getMyProfileInfo: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UserApi;


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

eval { 
    my $result = $api_instance->getMyProfileInfo();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserApi->getMyProfileInfo: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


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

try: 
    # Get user profile
    api_response = api_instance.get_my_profile_info()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserApi->getMyProfileInfo: %s\n" % e)

Parameters

Responses

Status: 200 - OK