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

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

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

        // Create an instance of the API class
        AccountsApi apiInstance = new AccountsApi();
        String paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the account belongs to
        UUID paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | The identifier of the Payment Account to retrieve the Authorisers.

        try {
            getAuthorisersResponse result = apiInstance.accountAuthoriserGet(paymentProviderName, paymentAccountGUID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#accountAuthoriserGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String paymentProviderName = new String(); // String | Identifier of the Payment Services Provider the account belongs to
final UUID paymentAccountGUID = new UUID(); // UUID | The identifier of the Payment Account to retrieve the Authorisers.

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

import org.openapitools.client.api.AccountsApi;

public class AccountsApiExample {
    public static void main(String[] args) {
        AccountsApi apiInstance = new AccountsApi();
        String paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the account belongs to
        UUID paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | The identifier of the Payment Account to retrieve the Authorisers.

        try {
            getAuthorisersResponse result = apiInstance.accountAuthoriserGet(paymentProviderName, paymentAccountGUID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#accountAuthoriserGet");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AccountsApi *apiInstance = [[AccountsApi alloc] init];
String *paymentProviderName = paymentProviderName_example; // Identifier of the Payment Services Provider the account belongs to (default to null)
UUID *paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // The identifier of the Payment Account to retrieve the Authorisers. (default to null)

// Gets the collection of authorisers and authorisation rules for a payment account.
[apiInstance accountAuthoriserGetWith:paymentProviderName
    paymentAccountGUID:paymentAccountGUID
              completionHandler: ^(getAuthorisersResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesPaymentServices = require('spenda_services_payment_services');

// Create an instance of the API class
var api = new SpendaServicesPaymentServices.AccountsApi()
var paymentProviderName = paymentProviderName_example; // {String} Identifier of the Payment Services Provider the account belongs to
var paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} The identifier of the Payment Account to retrieve the Authorisers.

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

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

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

            // Create an instance of the API class
            var apiInstance = new AccountsApi();
            var paymentProviderName = paymentProviderName_example;  // String | Identifier of the Payment Services Provider the account belongs to (default to null)
            var paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | The identifier of the Payment Account to retrieve the Authorisers. (default to null)

            try {
                // Gets the collection of authorisers and authorisation rules for a payment account.
                getAuthorisersResponse result = apiInstance.accountAuthoriserGet(paymentProviderName, paymentAccountGUID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsApi.accountAuthoriserGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccountsApi();
$paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the account belongs to
$paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | The identifier of the Payment Account to retrieve the Authorisers.

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AccountsApi->new();
my $paymentProviderName = paymentProviderName_example; # String | Identifier of the Payment Services Provider the account belongs to
my $paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | The identifier of the Payment Account to retrieve the Authorisers.

eval {
    my $result = $api_instance->accountAuthoriserGet(paymentProviderName => $paymentProviderName, paymentAccountGUID => $paymentAccountGUID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountsApi->accountAuthoriserGet: $@\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.AccountsApi()
paymentProviderName = paymentProviderName_example # String | Identifier of the Payment Services Provider the account belongs to (default to null)
paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | The identifier of the Payment Account to retrieve the Authorisers. (default to null)

try:
    # Gets the collection of authorisers and authorisation rules for a payment account.
    api_response = api_instance.account_authoriser_get(paymentProviderName, paymentAccountGUID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsApi->accountAuthoriserGet: %s\n" % e)

extern crate AccountsApi;

pub fn main() {
    let paymentProviderName = paymentProviderName_example; // String
    let paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = AccountsApi::Context::default();
    let result = client.accountAuthoriserGet(paymentProviderName, paymentAccountGUID, &context).wait();

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

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

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

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

        // Create an instance of the API class
        AccountsApi apiInstance = new AccountsApi();
        String paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the accounts belongs to
        String accountUsage = accountUsage_example; // String | Indicates whether to return Buyer or Supplier accounts. Defaults to Buyer.

        try {
            checkTenantsAccountConfiguration result = apiInstance.accountCheckConfigurations(paymentProviderName, accountUsage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#accountCheckConfigurations");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String paymentProviderName = new String(); // String | Identifier of the Payment Services Provider the accounts belongs to
final String accountUsage = new String(); // String | Indicates whether to return Buyer or Supplier accounts. Defaults to Buyer.

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

import org.openapitools.client.api.AccountsApi;

public class AccountsApiExample {
    public static void main(String[] args) {
        AccountsApi apiInstance = new AccountsApi();
        String paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the accounts belongs to
        String accountUsage = accountUsage_example; // String | Indicates whether to return Buyer or Supplier accounts. Defaults to Buyer.

        try {
            checkTenantsAccountConfiguration result = apiInstance.accountCheckConfigurations(paymentProviderName, accountUsage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#accountCheckConfigurations");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AccountsApi *apiInstance = [[AccountsApi alloc] init];
String *paymentProviderName = paymentProviderName_example; // Identifier of the Payment Services Provider the accounts belongs to (default to null)
String *accountUsage = accountUsage_example; // Indicates whether to return Buyer or Supplier accounts. Defaults to Buyer. (default to supplier)

// Validate if the user has onboarded SPS/ Firserve (MID) 
[apiInstance accountCheckConfigurationsWith:paymentProviderName
    accountUsage:accountUsage
              completionHandler: ^(checkTenantsAccountConfiguration output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesPaymentServices = require('spenda_services_payment_services');

// Create an instance of the API class
var api = new SpendaServicesPaymentServices.AccountsApi()
var paymentProviderName = paymentProviderName_example; // {String} Identifier of the Payment Services Provider the accounts belongs to
var accountUsage = accountUsage_example; // {String} Indicates whether to return Buyer or Supplier accounts. Defaults to Buyer.

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

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

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

            // Create an instance of the API class
            var apiInstance = new AccountsApi();
            var paymentProviderName = paymentProviderName_example;  // String | Identifier of the Payment Services Provider the accounts belongs to (default to null)
            var accountUsage = accountUsage_example;  // String | Indicates whether to return Buyer or Supplier accounts. Defaults to Buyer. (default to supplier)

            try {
                // Validate if the user has onboarded SPS/ Firserve (MID) 
                checkTenantsAccountConfiguration result = apiInstance.accountCheckConfigurations(paymentProviderName, accountUsage);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsApi.accountCheckConfigurations: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccountsApi();
$paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the accounts belongs to
$accountUsage = accountUsage_example; // String | Indicates whether to return Buyer or Supplier accounts. Defaults to Buyer.

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AccountsApi->new();
my $paymentProviderName = paymentProviderName_example; # String | Identifier of the Payment Services Provider the accounts belongs to
my $accountUsage = accountUsage_example; # String | Indicates whether to return Buyer or Supplier accounts. Defaults to Buyer.

eval {
    my $result = $api_instance->accountCheckConfigurations(paymentProviderName => $paymentProviderName, accountUsage => $accountUsage);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountsApi->accountCheckConfigurations: $@\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.AccountsApi()
paymentProviderName = paymentProviderName_example # String | Identifier of the Payment Services Provider the accounts belongs to (default to null)
accountUsage = accountUsage_example # String | Indicates whether to return Buyer or Supplier accounts. Defaults to Buyer. (default to supplier)

try:
    # Validate if the user has onboarded SPS/ Firserve (MID) 
    api_response = api_instance.account_check_configurations(paymentProviderName, accountUsage)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsApi->accountCheckConfigurations: %s\n" % e)

extern crate AccountsApi;

pub fn main() {
    let paymentProviderName = paymentProviderName_example; // String
    let accountUsage = accountUsage_example; // String

    let mut context = AccountsApi::Context::default();
    let result = client.accountCheckConfigurations(paymentProviderName, accountUsage, &context).wait();

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

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

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

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

        // Create an instance of the API class
        AccountsApi apiInstance = new AccountsApi();
        String paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the account belongs to
        UUID paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Identifier of the account to delete

        try {
            deleteAccountResponse result = apiInstance.accountDelete(paymentProviderName, paymentAccountGUID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#accountDelete");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String paymentProviderName = new String(); // String | Identifier of the Payment Services Provider the account belongs to
final UUID paymentAccountGUID = new UUID(); // UUID | Identifier of the account to delete

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

import org.openapitools.client.api.AccountsApi;

public class AccountsApiExample {
    public static void main(String[] args) {
        AccountsApi apiInstance = new AccountsApi();
        String paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the account belongs to
        UUID paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Identifier of the account to delete

        try {
            deleteAccountResponse result = apiInstance.accountDelete(paymentProviderName, paymentAccountGUID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#accountDelete");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AccountsApi *apiInstance = [[AccountsApi alloc] init];
String *paymentProviderName = paymentProviderName_example; // Identifier of the Payment Services Provider the account belongs to (default to null)
UUID *paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // Identifier of the account to delete (default to null)

// Deletes an account
[apiInstance accountDeleteWith:paymentProviderName
    paymentAccountGUID:paymentAccountGUID
              completionHandler: ^(deleteAccountResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesPaymentServices = require('spenda_services_payment_services');

// Create an instance of the API class
var api = new SpendaServicesPaymentServices.AccountsApi()
var paymentProviderName = paymentProviderName_example; // {String} Identifier of the Payment Services Provider the account belongs to
var paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} Identifier of the account to delete

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

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

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

            // Create an instance of the API class
            var apiInstance = new AccountsApi();
            var paymentProviderName = paymentProviderName_example;  // String | Identifier of the Payment Services Provider the account belongs to (default to null)
            var paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | Identifier of the account to delete (default to null)

            try {
                // Deletes an account
                deleteAccountResponse result = apiInstance.accountDelete(paymentProviderName, paymentAccountGUID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsApi.accountDelete: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccountsApi();
$paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the account belongs to
$paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Identifier of the account to delete

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AccountsApi->new();
my $paymentProviderName = paymentProviderName_example; # String | Identifier of the Payment Services Provider the account belongs to
my $paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | Identifier of the account to delete

eval {
    my $result = $api_instance->accountDelete(paymentProviderName => $paymentProviderName, paymentAccountGUID => $paymentAccountGUID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountsApi->accountDelete: $@\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.AccountsApi()
paymentProviderName = paymentProviderName_example # String | Identifier of the Payment Services Provider the account belongs to (default to null)
paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | Identifier of the account to delete (default to null)

try:
    # Deletes an account
    api_response = api_instance.account_delete(paymentProviderName, paymentAccountGUID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsApi->accountDelete: %s\n" % e)

extern crate AccountsApi;

pub fn main() {
    let paymentProviderName = paymentProviderName_example; // String
    let paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = AccountsApi::Context::default();
    let result = client.accountDelete(paymentProviderName, paymentAccountGUID, &context).wait();

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

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

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

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

        // Create an instance of the API class
        AccountsApi apiInstance = new AccountsApi();
        String paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the account belongs to
        UUID paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Identifier of the account to retrieve

        try {
            getAccountResponse result = apiInstance.accountGet(paymentProviderName, paymentAccountGUID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#accountGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String paymentProviderName = new String(); // String | Identifier of the Payment Services Provider the account belongs to
final UUID paymentAccountGUID = new UUID(); // UUID | Identifier of the account to retrieve

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

import org.openapitools.client.api.AccountsApi;

public class AccountsApiExample {
    public static void main(String[] args) {
        AccountsApi apiInstance = new AccountsApi();
        String paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the account belongs to
        UUID paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Identifier of the account to retrieve

        try {
            getAccountResponse result = apiInstance.accountGet(paymentProviderName, paymentAccountGUID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#accountGet");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AccountsApi *apiInstance = [[AccountsApi alloc] init];
String *paymentProviderName = paymentProviderName_example; // Identifier of the Payment Services Provider the account belongs to (default to null)
UUID *paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // Identifier of the account to retrieve (default to null)

// Gets an existing account
[apiInstance accountGetWith:paymentProviderName
    paymentAccountGUID:paymentAccountGUID
              completionHandler: ^(getAccountResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesPaymentServices = require('spenda_services_payment_services');

// Create an instance of the API class
var api = new SpendaServicesPaymentServices.AccountsApi()
var paymentProviderName = paymentProviderName_example; // {String} Identifier of the Payment Services Provider the account belongs to
var paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} Identifier of the account to retrieve

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

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

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

            // Create an instance of the API class
            var apiInstance = new AccountsApi();
            var paymentProviderName = paymentProviderName_example;  // String | Identifier of the Payment Services Provider the account belongs to (default to null)
            var paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | Identifier of the account to retrieve (default to null)

            try {
                // Gets an existing account
                getAccountResponse result = apiInstance.accountGet(paymentProviderName, paymentAccountGUID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsApi.accountGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccountsApi();
$paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the account belongs to
$paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Identifier of the account to retrieve

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AccountsApi->new();
my $paymentProviderName = paymentProviderName_example; # String | Identifier of the Payment Services Provider the account belongs to
my $paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | Identifier of the account to retrieve

eval {
    my $result = $api_instance->accountGet(paymentProviderName => $paymentProviderName, paymentAccountGUID => $paymentAccountGUID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountsApi->accountGet: $@\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.AccountsApi()
paymentProviderName = paymentProviderName_example # String | Identifier of the Payment Services Provider the account belongs to (default to null)
paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | Identifier of the account to retrieve (default to null)

try:
    # Gets an existing account
    api_response = api_instance.account_get(paymentProviderName, paymentAccountGUID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsApi->accountGet: %s\n" % e)

extern crate AccountsApi;

pub fn main() {
    let paymentProviderName = paymentProviderName_example; // String
    let paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = AccountsApi::Context::default();
    let result = client.accountGet(paymentProviderName, paymentAccountGUID, &context).wait();

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

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

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

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

        // Create an instance of the API class
        AccountsApi apiInstance = new AccountsApi();
        String paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the accounts belongs to
        UUID merchantGlobalID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | The Global Identifier of the Merchant Tenant
        String accountUsage = accountUsage_example; // String | Indicates whether to return Buyer or Supplier accounts. Defaults to Buyer.
        Boolean authorisedAccounts = true; // Boolean | Indicates whether to only return accounts for which the user is an Authoriser.
        String verificationStatus = verificationStatus_example; // String | Indicates whether to only return accounts with the verification status.
        String creditPaymentServiceName = creditPaymentServiceName_example; // String | This value will be used to filter the Payment Routes on Credit Payment Service Name

        try {
            array[getAccountResponse] result = apiInstance.accountGetAll(paymentProviderName, merchantGlobalID, accountUsage, authorisedAccounts, verificationStatus, creditPaymentServiceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#accountGetAll");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String paymentProviderName = new String(); // String | Identifier of the Payment Services Provider the accounts belongs to
final UUID merchantGlobalID = new UUID(); // UUID | The Global Identifier of the Merchant Tenant
final String accountUsage = new String(); // String | Indicates whether to return Buyer or Supplier accounts. Defaults to Buyer.
final Boolean authorisedAccounts = new Boolean(); // Boolean | Indicates whether to only return accounts for which the user is an Authoriser.
final String verificationStatus = new String(); // String | Indicates whether to only return accounts with the verification status.
final String creditPaymentServiceName = new String(); // String | This value will be used to filter the Payment Routes on Credit Payment Service Name

try {
    final result = await api_instance.accountGetAll(paymentProviderName, merchantGlobalID, accountUsage, authorisedAccounts, verificationStatus, creditPaymentServiceName);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->accountGetAll: $e\n');
}

import org.openapitools.client.api.AccountsApi;

public class AccountsApiExample {
    public static void main(String[] args) {
        AccountsApi apiInstance = new AccountsApi();
        String paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the accounts belongs to
        UUID merchantGlobalID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | The Global Identifier of the Merchant Tenant
        String accountUsage = accountUsage_example; // String | Indicates whether to return Buyer or Supplier accounts. Defaults to Buyer.
        Boolean authorisedAccounts = true; // Boolean | Indicates whether to only return accounts for which the user is an Authoriser.
        String verificationStatus = verificationStatus_example; // String | Indicates whether to only return accounts with the verification status.
        String creditPaymentServiceName = creditPaymentServiceName_example; // String | This value will be used to filter the Payment Routes on Credit Payment Service Name

        try {
            array[getAccountResponse] result = apiInstance.accountGetAll(paymentProviderName, merchantGlobalID, accountUsage, authorisedAccounts, verificationStatus, creditPaymentServiceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#accountGetAll");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AccountsApi *apiInstance = [[AccountsApi alloc] init];
String *paymentProviderName = paymentProviderName_example; // Identifier of the Payment Services Provider the accounts belongs to (default to null)
UUID *merchantGlobalID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // The Global Identifier of the Merchant Tenant (optional) (default to null)
String *accountUsage = accountUsage_example; // Indicates whether to return Buyer or Supplier accounts. Defaults to Buyer. (optional) (default to supplier)
Boolean *authorisedAccounts = true; // Indicates whether to only return accounts for which the user is an Authoriser. (optional) (default to null)
String *verificationStatus = verificationStatus_example; // Indicates whether to only return accounts with the verification status. (optional) (default to pending)
String *creditPaymentServiceName = creditPaymentServiceName_example; // This value will be used to filter the Payment Routes on Credit Payment Service Name (optional) (default to null)

// Gets list of accounts
[apiInstance accountGetAllWith:paymentProviderName
    merchantGlobalID:merchantGlobalID
    accountUsage:accountUsage
    authorisedAccounts:authorisedAccounts
    verificationStatus:verificationStatus
    creditPaymentServiceName:creditPaymentServiceName
              completionHandler: ^(array[getAccountResponse] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesPaymentServices = require('spenda_services_payment_services');

// Create an instance of the API class
var api = new SpendaServicesPaymentServices.AccountsApi()
var paymentProviderName = paymentProviderName_example; // {String} Identifier of the Payment Services Provider the accounts belongs to
var opts = {
  'merchantGlobalID': 38400000-8cf0-11bd-b23e-10b96e4ef00d, // {UUID} The Global Identifier of the Merchant Tenant
  'accountUsage': accountUsage_example, // {String} Indicates whether to return Buyer or Supplier accounts. Defaults to Buyer.
  'authorisedAccounts': true, // {Boolean} Indicates whether to only return accounts for which the user is an Authoriser.
  'verificationStatus': verificationStatus_example, // {String} Indicates whether to only return accounts with the verification status.
  'creditPaymentServiceName': creditPaymentServiceName_example // {String} This value will be used to filter the Payment Routes on Credit Payment Service Name
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new AccountsApi();
            var paymentProviderName = paymentProviderName_example;  // String | Identifier of the Payment Services Provider the accounts belongs to (default to null)
            var merchantGlobalID = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | The Global Identifier of the Merchant Tenant (optional)  (default to null)
            var accountUsage = accountUsage_example;  // String | Indicates whether to return Buyer or Supplier accounts. Defaults to Buyer. (optional)  (default to supplier)
            var authorisedAccounts = true;  // Boolean | Indicates whether to only return accounts for which the user is an Authoriser. (optional)  (default to null)
            var verificationStatus = verificationStatus_example;  // String | Indicates whether to only return accounts with the verification status. (optional)  (default to pending)
            var creditPaymentServiceName = creditPaymentServiceName_example;  // String | This value will be used to filter the Payment Routes on Credit Payment Service Name (optional)  (default to null)

            try {
                // Gets list of accounts
                array[getAccountResponse] result = apiInstance.accountGetAll(paymentProviderName, merchantGlobalID, accountUsage, authorisedAccounts, verificationStatus, creditPaymentServiceName);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsApi.accountGetAll: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccountsApi();
$paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the accounts belongs to
$merchantGlobalID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | The Global Identifier of the Merchant Tenant
$accountUsage = accountUsage_example; // String | Indicates whether to return Buyer or Supplier accounts. Defaults to Buyer.
$authorisedAccounts = true; // Boolean | Indicates whether to only return accounts for which the user is an Authoriser.
$verificationStatus = verificationStatus_example; // String | Indicates whether to only return accounts with the verification status.
$creditPaymentServiceName = creditPaymentServiceName_example; // String | This value will be used to filter the Payment Routes on Credit Payment Service Name

try {
    $result = $api_instance->accountGetAll($paymentProviderName, $merchantGlobalID, $accountUsage, $authorisedAccounts, $verificationStatus, $creditPaymentServiceName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AccountsApi->accountGetAll: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AccountsApi->new();
my $paymentProviderName = paymentProviderName_example; # String | Identifier of the Payment Services Provider the accounts belongs to
my $merchantGlobalID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | The Global Identifier of the Merchant Tenant
my $accountUsage = accountUsage_example; # String | Indicates whether to return Buyer or Supplier accounts. Defaults to Buyer.
my $authorisedAccounts = true; # Boolean | Indicates whether to only return accounts for which the user is an Authoriser.
my $verificationStatus = verificationStatus_example; # String | Indicates whether to only return accounts with the verification status.
my $creditPaymentServiceName = creditPaymentServiceName_example; # String | This value will be used to filter the Payment Routes on Credit Payment Service Name

eval {
    my $result = $api_instance->accountGetAll(paymentProviderName => $paymentProviderName, merchantGlobalID => $merchantGlobalID, accountUsage => $accountUsage, authorisedAccounts => $authorisedAccounts, verificationStatus => $verificationStatus, creditPaymentServiceName => $creditPaymentServiceName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountsApi->accountGetAll: $@\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.AccountsApi()
paymentProviderName = paymentProviderName_example # String | Identifier of the Payment Services Provider the accounts belongs to (default to null)
merchantGlobalID = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | The Global Identifier of the Merchant Tenant (optional) (default to null)
accountUsage = accountUsage_example # String | Indicates whether to return Buyer or Supplier accounts. Defaults to Buyer. (optional) (default to supplier)
authorisedAccounts = true # Boolean | Indicates whether to only return accounts for which the user is an Authoriser. (optional) (default to null)
verificationStatus = verificationStatus_example # String | Indicates whether to only return accounts with the verification status. (optional) (default to pending)
creditPaymentServiceName = creditPaymentServiceName_example # String | This value will be used to filter the Payment Routes on Credit Payment Service Name (optional) (default to null)

try:
    # Gets list of accounts
    api_response = api_instance.account_get_all(paymentProviderName, merchantGlobalID=merchantGlobalID, accountUsage=accountUsage, authorisedAccounts=authorisedAccounts, verificationStatus=verificationStatus, creditPaymentServiceName=creditPaymentServiceName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsApi->accountGetAll: %s\n" % e)

extern crate AccountsApi;

pub fn main() {
    let paymentProviderName = paymentProviderName_example; // String
    let merchantGlobalID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let accountUsage = accountUsage_example; // String
    let authorisedAccounts = true; // Boolean
    let verificationStatus = verificationStatus_example; // String
    let creditPaymentServiceName = creditPaymentServiceName_example; // String

    let mut context = AccountsApi::Context::default();
    let result = client.accountGetAll(paymentProviderName, merchantGlobalID, accountUsage, authorisedAccounts, verificationStatus, creditPaymentServiceName, &context).wait();

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

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

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

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

        // Create an instance of the API class
        AccountsApi apiInstance = new AccountsApi();
        String paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the account belongs to
        UUID paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Identifier of the account being verified

        try {
            getAccountResponse result = apiInstance.accountInitiateVerification(paymentProviderName, paymentAccountGUID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#accountInitiateVerification");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String paymentProviderName = new String(); // String | Identifier of the Payment Services Provider the account belongs to
final UUID paymentAccountGUID = new UUID(); // UUID | Identifier of the account being verified

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

import org.openapitools.client.api.AccountsApi;

public class AccountsApiExample {
    public static void main(String[] args) {
        AccountsApi apiInstance = new AccountsApi();
        String paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the account belongs to
        UUID paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Identifier of the account being verified

        try {
            getAccountResponse result = apiInstance.accountInitiateVerification(paymentProviderName, paymentAccountGUID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#accountInitiateVerification");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AccountsApi *apiInstance = [[AccountsApi alloc] init];
String *paymentProviderName = paymentProviderName_example; // Identifier of the Payment Services Provider the account belongs to (default to null)
UUID *paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // Identifier of the account being verified (default to null)

// Causes a verification transaction to be initiated
[apiInstance accountInitiateVerificationWith:paymentProviderName
    paymentAccountGUID:paymentAccountGUID
              completionHandler: ^(getAccountResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesPaymentServices = require('spenda_services_payment_services');

// Create an instance of the API class
var api = new SpendaServicesPaymentServices.AccountsApi()
var paymentProviderName = paymentProviderName_example; // {String} Identifier of the Payment Services Provider the account belongs to
var paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} Identifier of the account being verified

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

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

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

            // Create an instance of the API class
            var apiInstance = new AccountsApi();
            var paymentProviderName = paymentProviderName_example;  // String | Identifier of the Payment Services Provider the account belongs to (default to null)
            var paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | Identifier of the account being verified (default to null)

            try {
                // Causes a verification transaction to be initiated
                getAccountResponse result = apiInstance.accountInitiateVerification(paymentProviderName, paymentAccountGUID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsApi.accountInitiateVerification: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccountsApi();
$paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the account belongs to
$paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Identifier of the account being verified

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AccountsApi->new();
my $paymentProviderName = paymentProviderName_example; # String | Identifier of the Payment Services Provider the account belongs to
my $paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | Identifier of the account being verified

eval {
    my $result = $api_instance->accountInitiateVerification(paymentProviderName => $paymentProviderName, paymentAccountGUID => $paymentAccountGUID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountsApi->accountInitiateVerification: $@\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.AccountsApi()
paymentProviderName = paymentProviderName_example # String | Identifier of the Payment Services Provider the account belongs to (default to null)
paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | Identifier of the account being verified (default to null)

try:
    # Causes a verification transaction to be initiated
    api_response = api_instance.account_initiate_verification(paymentProviderName, paymentAccountGUID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsApi->accountInitiateVerification: %s\n" % e)

extern crate AccountsApi;

pub fn main() {
    let paymentProviderName = paymentProviderName_example; // String
    let paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = AccountsApi::Context::default();
    let result = client.accountInitiateVerification(paymentProviderName, paymentAccountGUID, &context).wait();

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

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

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

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

        // Create an instance of the API class
        AccountsApi apiInstance = new AccountsApi();
        String paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the account belongs to
        UUID paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Identifier of the account being verified

        try {
            getAccountResponse result = apiInstance.accountRetryVerification(paymentProviderName, paymentAccountGUID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#accountRetryVerification");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String paymentProviderName = new String(); // String | Identifier of the Payment Services Provider the account belongs to
final UUID paymentAccountGUID = new UUID(); // UUID | Identifier of the account being verified

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

import org.openapitools.client.api.AccountsApi;

public class AccountsApiExample {
    public static void main(String[] args) {
        AccountsApi apiInstance = new AccountsApi();
        String paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the account belongs to
        UUID paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Identifier of the account being verified

        try {
            getAccountResponse result = apiInstance.accountRetryVerification(paymentProviderName, paymentAccountGUID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#accountRetryVerification");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AccountsApi *apiInstance = [[AccountsApi alloc] init];
String *paymentProviderName = paymentProviderName_example; // Identifier of the Payment Services Provider the account belongs to (default to null)
UUID *paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // Identifier of the account being verified (default to null)

// Causes another verification transaction to be initiated
[apiInstance accountRetryVerificationWith:paymentProviderName
    paymentAccountGUID:paymentAccountGUID
              completionHandler: ^(getAccountResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesPaymentServices = require('spenda_services_payment_services');

// Create an instance of the API class
var api = new SpendaServicesPaymentServices.AccountsApi()
var paymentProviderName = paymentProviderName_example; // {String} Identifier of the Payment Services Provider the account belongs to
var paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} Identifier of the account being verified

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

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

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

            // Create an instance of the API class
            var apiInstance = new AccountsApi();
            var paymentProviderName = paymentProviderName_example;  // String | Identifier of the Payment Services Provider the account belongs to (default to null)
            var paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | Identifier of the account being verified (default to null)

            try {
                // Causes another verification transaction to be initiated
                getAccountResponse result = apiInstance.accountRetryVerification(paymentProviderName, paymentAccountGUID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsApi.accountRetryVerification: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccountsApi();
$paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the account belongs to
$paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Identifier of the account being verified

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AccountsApi->new();
my $paymentProviderName = paymentProviderName_example; # String | Identifier of the Payment Services Provider the account belongs to
my $paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | Identifier of the account being verified

eval {
    my $result = $api_instance->accountRetryVerification(paymentProviderName => $paymentProviderName, paymentAccountGUID => $paymentAccountGUID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountsApi->accountRetryVerification: $@\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.AccountsApi()
paymentProviderName = paymentProviderName_example # String | Identifier of the Payment Services Provider the account belongs to (default to null)
paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | Identifier of the account being verified (default to null)

try:
    # Causes another verification transaction to be initiated
    api_response = api_instance.account_retry_verification(paymentProviderName, paymentAccountGUID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsApi->accountRetryVerification: %s\n" % e)

extern crate AccountsApi;

pub fn main() {
    let paymentProviderName = paymentProviderName_example; // String
    let paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = AccountsApi::Context::default();
    let result = client.accountRetryVerification(paymentProviderName, paymentAccountGUID, &context).wait();

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

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

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

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

        // Create an instance of the API class
        AccountsApi apiInstance = new AccountsApi();
        String paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the account belongs to
        UUID paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Identifier of the account to update
        SaveAccountRequest saveAccountRequest = {"friendlyName":"string","isInvigoDefault":true,"authorisationRules":{"isAuthorisationRequired":true,"isApprovalCodeRequired":true,"authorisationRequestMode":"Parallel","requiredApprovalCount":0,"authoriserUserIDs":[0]}}; // SaveAccountRequest | 

        try {
            getAccountResponse result = apiInstance.accountSave(paymentProviderName, paymentAccountGUID, saveAccountRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#accountSave");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String paymentProviderName = new String(); // String | Identifier of the Payment Services Provider the account belongs to
final UUID paymentAccountGUID = new UUID(); // UUID | Identifier of the account to update
final SaveAccountRequest saveAccountRequest = new SaveAccountRequest(); // SaveAccountRequest | 

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

import org.openapitools.client.api.AccountsApi;

public class AccountsApiExample {
    public static void main(String[] args) {
        AccountsApi apiInstance = new AccountsApi();
        String paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the account belongs to
        UUID paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Identifier of the account to update
        SaveAccountRequest saveAccountRequest = {"friendlyName":"string","isInvigoDefault":true,"authorisationRules":{"isAuthorisationRequired":true,"isApprovalCodeRequired":true,"authorisationRequestMode":"Parallel","requiredApprovalCount":0,"authoriserUserIDs":[0]}}; // SaveAccountRequest | 

        try {
            getAccountResponse result = apiInstance.accountSave(paymentProviderName, paymentAccountGUID, saveAccountRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#accountSave");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AccountsApi *apiInstance = [[AccountsApi alloc] init];
String *paymentProviderName = paymentProviderName_example; // Identifier of the Payment Services Provider the account belongs to (default to null)
UUID *paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // Identifier of the account to update (default to null)
SaveAccountRequest *saveAccountRequest = {"friendlyName":"string","isInvigoDefault":true,"authorisationRules":{"isAuthorisationRequired":true,"isApprovalCodeRequired":true,"authorisationRequestMode":"Parallel","requiredApprovalCount":0,"authoriserUserIDs":[0]}}; //  (optional)

// Saves the details of a Payment Account.
[apiInstance accountSaveWith:paymentProviderName
    paymentAccountGUID:paymentAccountGUID
    saveAccountRequest:saveAccountRequest
              completionHandler: ^(getAccountResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesPaymentServices = require('spenda_services_payment_services');

// Create an instance of the API class
var api = new SpendaServicesPaymentServices.AccountsApi()
var paymentProviderName = paymentProviderName_example; // {String} Identifier of the Payment Services Provider the account belongs to
var paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} Identifier of the account to update
var opts = {
  'saveAccountRequest': {"friendlyName":"string","isInvigoDefault":true,"authorisationRules":{"isAuthorisationRequired":true,"isApprovalCodeRequired":true,"authorisationRequestMode":"Parallel","requiredApprovalCount":0,"authoriserUserIDs":[0]}} // {SaveAccountRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new AccountsApi();
            var paymentProviderName = paymentProviderName_example;  // String | Identifier of the Payment Services Provider the account belongs to (default to null)
            var paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | Identifier of the account to update (default to null)
            var saveAccountRequest = new SaveAccountRequest(); // SaveAccountRequest |  (optional) 

            try {
                // Saves the details of a Payment Account.
                getAccountResponse result = apiInstance.accountSave(paymentProviderName, paymentAccountGUID, saveAccountRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsApi.accountSave: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccountsApi();
$paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the account belongs to
$paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Identifier of the account to update
$saveAccountRequest = {"friendlyName":"string","isInvigoDefault":true,"authorisationRules":{"isAuthorisationRequired":true,"isApprovalCodeRequired":true,"authorisationRequestMode":"Parallel","requiredApprovalCount":0,"authoriserUserIDs":[0]}}; // SaveAccountRequest | 

try {
    $result = $api_instance->accountSave($paymentProviderName, $paymentAccountGUID, $saveAccountRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AccountsApi->accountSave: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AccountsApi->new();
my $paymentProviderName = paymentProviderName_example; # String | Identifier of the Payment Services Provider the account belongs to
my $paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | Identifier of the account to update
my $saveAccountRequest = WWW::OPenAPIClient::Object::SaveAccountRequest->new(); # SaveAccountRequest | 

eval {
    my $result = $api_instance->accountSave(paymentProviderName => $paymentProviderName, paymentAccountGUID => $paymentAccountGUID, saveAccountRequest => $saveAccountRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountsApi->accountSave: $@\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.AccountsApi()
paymentProviderName = paymentProviderName_example # String | Identifier of the Payment Services Provider the account belongs to (default to null)
paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | Identifier of the account to update (default to null)
saveAccountRequest = {"friendlyName":"string","isInvigoDefault":true,"authorisationRules":{"isAuthorisationRequired":true,"isApprovalCodeRequired":true,"authorisationRequestMode":"Parallel","requiredApprovalCount":0,"authoriserUserIDs":[0]}} # SaveAccountRequest |  (optional)

try:
    # Saves the details of a Payment Account.
    api_response = api_instance.account_save(paymentProviderName, paymentAccountGUID, saveAccountRequest=saveAccountRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsApi->accountSave: %s\n" % e)

extern crate AccountsApi;

pub fn main() {
    let paymentProviderName = paymentProviderName_example; // String
    let paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let saveAccountRequest = {"friendlyName":"string","isInvigoDefault":true,"authorisationRules":{"isAuthorisationRequired":true,"isApprovalCodeRequired":true,"authorisationRequestMode":"Parallel","requiredApprovalCount":0,"authoriserUserIDs":[0]}}; // SaveAccountRequest

    let mut context = AccountsApi::Context::default();
    let result = client.accountSave(paymentProviderName, paymentAccountGUID, saveAccountRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        AccountsApi apiInstance = new AccountsApi();
        String paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the account belongs to
        UUID paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Identifier of the account to retrieve
        Integer linkedSupplierID = 56; // Integer | Supplier Identifier in Accounts Receivable

        try {
            array[paymentTransactionSummary] result = apiInstance.accountTransactionsGet(paymentProviderName, paymentAccountGUID, linkedSupplierID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#accountTransactionsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String paymentProviderName = new String(); // String | Identifier of the Payment Services Provider the account belongs to
final UUID paymentAccountGUID = new UUID(); // UUID | Identifier of the account to retrieve
final Integer linkedSupplierID = new Integer(); // Integer | Supplier Identifier in Accounts Receivable

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

import org.openapitools.client.api.AccountsApi;

public class AccountsApiExample {
    public static void main(String[] args) {
        AccountsApi apiInstance = new AccountsApi();
        String paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the account belongs to
        UUID paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Identifier of the account to retrieve
        Integer linkedSupplierID = 56; // Integer | Supplier Identifier in Accounts Receivable

        try {
            array[paymentTransactionSummary] result = apiInstance.accountTransactionsGet(paymentProviderName, paymentAccountGUID, linkedSupplierID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#accountTransactionsGet");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AccountsApi *apiInstance = [[AccountsApi alloc] init];
String *paymentProviderName = paymentProviderName_example; // Identifier of the Payment Services Provider the account belongs to (default to null)
UUID *paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // Identifier of the account to retrieve (default to null)
Integer *linkedSupplierID = 56; // Supplier Identifier in Accounts Receivable (optional) (default to null)

// Gets all approved payment transactions related to PaymentProviderName and AccountGUID
[apiInstance accountTransactionsGetWith:paymentProviderName
    paymentAccountGUID:paymentAccountGUID
    linkedSupplierID:linkedSupplierID
              completionHandler: ^(array[paymentTransactionSummary] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesPaymentServices = require('spenda_services_payment_services');

// Create an instance of the API class
var api = new SpendaServicesPaymentServices.AccountsApi()
var paymentProviderName = paymentProviderName_example; // {String} Identifier of the Payment Services Provider the account belongs to
var paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} Identifier of the account to retrieve
var opts = {
  'linkedSupplierID': 56 // {Integer} Supplier Identifier in Accounts Receivable
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new AccountsApi();
            var paymentProviderName = paymentProviderName_example;  // String | Identifier of the Payment Services Provider the account belongs to (default to null)
            var paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | Identifier of the account to retrieve (default to null)
            var linkedSupplierID = 56;  // Integer | Supplier Identifier in Accounts Receivable (optional)  (default to null)

            try {
                // Gets all approved payment transactions related to PaymentProviderName and AccountGUID
                array[paymentTransactionSummary] result = apiInstance.accountTransactionsGet(paymentProviderName, paymentAccountGUID, linkedSupplierID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsApi.accountTransactionsGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccountsApi();
$paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the account belongs to
$paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Identifier of the account to retrieve
$linkedSupplierID = 56; // Integer | Supplier Identifier in Accounts Receivable

try {
    $result = $api_instance->accountTransactionsGet($paymentProviderName, $paymentAccountGUID, $linkedSupplierID);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AccountsApi->accountTransactionsGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AccountsApi->new();
my $paymentProviderName = paymentProviderName_example; # String | Identifier of the Payment Services Provider the account belongs to
my $paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | Identifier of the account to retrieve
my $linkedSupplierID = 56; # Integer | Supplier Identifier in Accounts Receivable

eval {
    my $result = $api_instance->accountTransactionsGet(paymentProviderName => $paymentProviderName, paymentAccountGUID => $paymentAccountGUID, linkedSupplierID => $linkedSupplierID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountsApi->accountTransactionsGet: $@\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.AccountsApi()
paymentProviderName = paymentProviderName_example # String | Identifier of the Payment Services Provider the account belongs to (default to null)
paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | Identifier of the account to retrieve (default to null)
linkedSupplierID = 56 # Integer | Supplier Identifier in Accounts Receivable (optional) (default to null)

try:
    # Gets all approved payment transactions related to PaymentProviderName and AccountGUID
    api_response = api_instance.account_transactions_get(paymentProviderName, paymentAccountGUID, linkedSupplierID=linkedSupplierID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsApi->accountTransactionsGet: %s\n" % e)

extern crate AccountsApi;

pub fn main() {
    let paymentProviderName = paymentProviderName_example; // String
    let paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let linkedSupplierID = 56; // Integer

    let mut context = AccountsApi::Context::default();
    let result = client.accountTransactionsGet(paymentProviderName, paymentAccountGUID, linkedSupplierID, &context).wait();

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

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

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

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

        // Create an instance of the API class
        AccountsApi apiInstance = new AccountsApi();
        String paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the account belongs to
        UUID paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Identifier of the account to verify
        VerifyAccountRequest verifyAccountRequest = {"verificationCode":"string"}; // VerifyAccountRequest | 

        try {
            getAccountResponse result = apiInstance.accountVerify(paymentProviderName, paymentAccountGUID, verifyAccountRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#accountVerify");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String paymentProviderName = new String(); // String | Identifier of the Payment Services Provider the account belongs to
final UUID paymentAccountGUID = new UUID(); // UUID | Identifier of the account to verify
final VerifyAccountRequest verifyAccountRequest = new VerifyAccountRequest(); // VerifyAccountRequest | 

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

import org.openapitools.client.api.AccountsApi;

public class AccountsApiExample {
    public static void main(String[] args) {
        AccountsApi apiInstance = new AccountsApi();
        String paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the account belongs to
        UUID paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Identifier of the account to verify
        VerifyAccountRequest verifyAccountRequest = {"verificationCode":"string"}; // VerifyAccountRequest | 

        try {
            getAccountResponse result = apiInstance.accountVerify(paymentProviderName, paymentAccountGUID, verifyAccountRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#accountVerify");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AccountsApi *apiInstance = [[AccountsApi alloc] init];
String *paymentProviderName = paymentProviderName_example; // Identifier of the Payment Services Provider the account belongs to (default to null)
UUID *paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // Identifier of the account to verify (default to null)
VerifyAccountRequest *verifyAccountRequest = {"verificationCode":"string"}; //  (optional)

// Attempts to verify an account
[apiInstance accountVerifyWith:paymentProviderName
    paymentAccountGUID:paymentAccountGUID
    verifyAccountRequest:verifyAccountRequest
              completionHandler: ^(getAccountResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesPaymentServices = require('spenda_services_payment_services');

// Create an instance of the API class
var api = new SpendaServicesPaymentServices.AccountsApi()
var paymentProviderName = paymentProviderName_example; // {String} Identifier of the Payment Services Provider the account belongs to
var paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} Identifier of the account to verify
var opts = {
  'verifyAccountRequest': {"verificationCode":"string"} // {VerifyAccountRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new AccountsApi();
            var paymentProviderName = paymentProviderName_example;  // String | Identifier of the Payment Services Provider the account belongs to (default to null)
            var paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | Identifier of the account to verify (default to null)
            var verifyAccountRequest = new VerifyAccountRequest(); // VerifyAccountRequest |  (optional) 

            try {
                // Attempts to verify an account
                getAccountResponse result = apiInstance.accountVerify(paymentProviderName, paymentAccountGUID, verifyAccountRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsApi.accountVerify: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccountsApi();
$paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the account belongs to
$paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Identifier of the account to verify
$verifyAccountRequest = {"verificationCode":"string"}; // VerifyAccountRequest | 

try {
    $result = $api_instance->accountVerify($paymentProviderName, $paymentAccountGUID, $verifyAccountRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AccountsApi->accountVerify: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AccountsApi->new();
my $paymentProviderName = paymentProviderName_example; # String | Identifier of the Payment Services Provider the account belongs to
my $paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | Identifier of the account to verify
my $verifyAccountRequest = WWW::OPenAPIClient::Object::VerifyAccountRequest->new(); # VerifyAccountRequest | 

eval {
    my $result = $api_instance->accountVerify(paymentProviderName => $paymentProviderName, paymentAccountGUID => $paymentAccountGUID, verifyAccountRequest => $verifyAccountRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountsApi->accountVerify: $@\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.AccountsApi()
paymentProviderName = paymentProviderName_example # String | Identifier of the Payment Services Provider the account belongs to (default to null)
paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | Identifier of the account to verify (default to null)
verifyAccountRequest = {"verificationCode":"string"} # VerifyAccountRequest |  (optional)

try:
    # Attempts to verify an account
    api_response = api_instance.account_verify(paymentProviderName, paymentAccountGUID, verifyAccountRequest=verifyAccountRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsApi->accountVerify: %s\n" % e)

extern crate AccountsApi;

pub fn main() {
    let paymentProviderName = paymentProviderName_example; // String
    let paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let verifyAccountRequest = {"verificationCode":"string"}; // VerifyAccountRequest

    let mut context = AccountsApi::Context::default();
    let result = client.accountVerify(paymentProviderName, paymentAccountGUID, verifyAccountRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        AccountsApi apiInstance = new AccountsApi();
        String paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the account belongs to
        PaymentAuthoriseRequest paymentAuthoriseRequest = {"paymentAccountGUID":"string","paymentMethod":"Eftpos","paymentAmount":0,"recipientName":"string","merchantTenantGlobalID":"string","paymentBatchID":0}; // PaymentAuthoriseRequest | 

        try {
            authorisePaymentResponse result = apiInstance.paymentAuthorisePost(paymentProviderName, paymentAuthoriseRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#paymentAuthorisePost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String paymentProviderName = new String(); // String | Identifier of the Payment Services Provider the account belongs to
final PaymentAuthoriseRequest paymentAuthoriseRequest = new PaymentAuthoriseRequest(); // PaymentAuthoriseRequest | 

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

import org.openapitools.client.api.AccountsApi;

public class AccountsApiExample {
    public static void main(String[] args) {
        AccountsApi apiInstance = new AccountsApi();
        String paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the account belongs to
        PaymentAuthoriseRequest paymentAuthoriseRequest = {"paymentAccountGUID":"string","paymentMethod":"Eftpos","paymentAmount":0,"recipientName":"string","merchantTenantGlobalID":"string","paymentBatchID":0}; // PaymentAuthoriseRequest | 

        try {
            authorisePaymentResponse result = apiInstance.paymentAuthorisePost(paymentProviderName, paymentAuthoriseRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#paymentAuthorisePost");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AccountsApi *apiInstance = [[AccountsApi alloc] init];
String *paymentProviderName = paymentProviderName_example; // Identifier of the Payment Services Provider the account belongs to (default to null)
PaymentAuthoriseRequest *paymentAuthoriseRequest = {"paymentAccountGUID":"string","paymentMethod":"Eftpos","paymentAmount":0,"recipientName":"string","merchantTenantGlobalID":"string","paymentBatchID":0}; //  (optional)

// Begins the authorisation process for a new payment. This must be called before submitting the payment.
[apiInstance paymentAuthorisePostWith:paymentProviderName
    paymentAuthoriseRequest:paymentAuthoriseRequest
              completionHandler: ^(authorisePaymentResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesPaymentServices = require('spenda_services_payment_services');

// Create an instance of the API class
var api = new SpendaServicesPaymentServices.AccountsApi()
var paymentProviderName = paymentProviderName_example; // {String} Identifier of the Payment Services Provider the account belongs to
var opts = {
  'paymentAuthoriseRequest': {"paymentAccountGUID":"string","paymentMethod":"Eftpos","paymentAmount":0,"recipientName":"string","merchantTenantGlobalID":"string","paymentBatchID":0} // {PaymentAuthoriseRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new AccountsApi();
            var paymentProviderName = paymentProviderName_example;  // String | Identifier of the Payment Services Provider the account belongs to (default to null)
            var paymentAuthoriseRequest = new PaymentAuthoriseRequest(); // PaymentAuthoriseRequest |  (optional) 

            try {
                // Begins the authorisation process for a new payment. This must be called before submitting the payment.
                authorisePaymentResponse result = apiInstance.paymentAuthorisePost(paymentProviderName, paymentAuthoriseRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsApi.paymentAuthorisePost: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccountsApi();
$paymentProviderName = paymentProviderName_example; // String | Identifier of the Payment Services Provider the account belongs to
$paymentAuthoriseRequest = {"paymentAccountGUID":"string","paymentMethod":"Eftpos","paymentAmount":0,"recipientName":"string","merchantTenantGlobalID":"string","paymentBatchID":0}; // PaymentAuthoriseRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AccountsApi->new();
my $paymentProviderName = paymentProviderName_example; # String | Identifier of the Payment Services Provider the account belongs to
my $paymentAuthoriseRequest = WWW::OPenAPIClient::Object::PaymentAuthoriseRequest->new(); # PaymentAuthoriseRequest | 

eval {
    my $result = $api_instance->paymentAuthorisePost(paymentProviderName => $paymentProviderName, paymentAuthoriseRequest => $paymentAuthoriseRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountsApi->paymentAuthorisePost: $@\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.AccountsApi()
paymentProviderName = paymentProviderName_example # String | Identifier of the Payment Services Provider the account belongs to (default to null)
paymentAuthoriseRequest = {"paymentAccountGUID":"string","paymentMethod":"Eftpos","paymentAmount":0,"recipientName":"string","merchantTenantGlobalID":"string","paymentBatchID":0} # PaymentAuthoriseRequest |  (optional)

try:
    # Begins the authorisation process for a new payment. This must be called before submitting the payment.
    api_response = api_instance.payment_authorise_post(paymentProviderName, paymentAuthoriseRequest=paymentAuthoriseRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsApi->paymentAuthorisePost: %s\n" % e)

extern crate AccountsApi;

pub fn main() {
    let paymentProviderName = paymentProviderName_example; // String
    let paymentAuthoriseRequest = {"paymentAccountGUID":"string","paymentMethod":"Eftpos","paymentAmount":0,"recipientName":"string","merchantTenantGlobalID":"string","paymentBatchID":0}; // PaymentAuthoriseRequest

    let mut context = AccountsApi::Context::default();
    let result = client.paymentAuthorisePost(paymentProviderName, paymentAuthoriseRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        FeesApi apiInstance = new FeesApi();
        String paymentProviderName = paymentProviderName_example; // String | The Payment Service Provider Name
        Double paymentAmount = 1.2; // Double | The payment amount to calculate the fee.
        UUID merchantGlobalID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | The Merchant Tenant identifier.
        String accountUsage = accountUsage_example; // String | Filter the result.
        String verificationStatus = verificationStatus_example; // String | Filter the result.
        String creditPaymentServiceName = creditPaymentServiceName_example; // String | This value will be used to filter the Payment Routes on Credit Payment Service Name

        try {
            array[getAccountResponse] result = apiInstance.paymentAccountCalculateFee(paymentProviderName, paymentAmount, merchantGlobalID, accountUsage, verificationStatus, creditPaymentServiceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FeesApi#paymentAccountCalculateFee");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String paymentProviderName = new String(); // String | The Payment Service Provider Name
final Double paymentAmount = new Double(); // Double | The payment amount to calculate the fee.
final UUID merchantGlobalID = new UUID(); // UUID | The Merchant Tenant identifier.
final String accountUsage = new String(); // String | Filter the result.
final String verificationStatus = new String(); // String | Filter the result.
final String creditPaymentServiceName = new String(); // String | This value will be used to filter the Payment Routes on Credit Payment Service Name

try {
    final result = await api_instance.paymentAccountCalculateFee(paymentProviderName, paymentAmount, merchantGlobalID, accountUsage, verificationStatus, creditPaymentServiceName);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->paymentAccountCalculateFee: $e\n');
}

import org.openapitools.client.api.FeesApi;

public class FeesApiExample {
    public static void main(String[] args) {
        FeesApi apiInstance = new FeesApi();
        String paymentProviderName = paymentProviderName_example; // String | The Payment Service Provider Name
        Double paymentAmount = 1.2; // Double | The payment amount to calculate the fee.
        UUID merchantGlobalID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | The Merchant Tenant identifier.
        String accountUsage = accountUsage_example; // String | Filter the result.
        String verificationStatus = verificationStatus_example; // String | Filter the result.
        String creditPaymentServiceName = creditPaymentServiceName_example; // String | This value will be used to filter the Payment Routes on Credit Payment Service Name

        try {
            array[getAccountResponse] result = apiInstance.paymentAccountCalculateFee(paymentProviderName, paymentAmount, merchantGlobalID, accountUsage, verificationStatus, creditPaymentServiceName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FeesApi#paymentAccountCalculateFee");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
FeesApi *apiInstance = [[FeesApi alloc] init];
String *paymentProviderName = paymentProviderName_example; // The Payment Service Provider Name (default to null)
Double *paymentAmount = 1.2; // The payment amount to calculate the fee. (default to null)
UUID *merchantGlobalID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // The Merchant Tenant identifier. (optional) (default to null)
String *accountUsage = accountUsage_example; // Filter the result. (optional) (default to supplier)
String *verificationStatus = verificationStatus_example; // Filter the result. (optional) (default to pending)
String *creditPaymentServiceName = creditPaymentServiceName_example; // This value will be used to filter the Payment Routes on Credit Payment Service Name (optional) (default to null)

// Calculates fees payable.
[apiInstance paymentAccountCalculateFeeWith:paymentProviderName
    paymentAmount:paymentAmount
    merchantGlobalID:merchantGlobalID
    accountUsage:accountUsage
    verificationStatus:verificationStatus
    creditPaymentServiceName:creditPaymentServiceName
              completionHandler: ^(array[getAccountResponse] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesPaymentServices = require('spenda_services_payment_services');

// Create an instance of the API class
var api = new SpendaServicesPaymentServices.FeesApi()
var paymentProviderName = paymentProviderName_example; // {String} The Payment Service Provider Name
var paymentAmount = 1.2; // {Double} The payment amount to calculate the fee.
var opts = {
  'merchantGlobalID': 38400000-8cf0-11bd-b23e-10b96e4ef00d, // {UUID} The Merchant Tenant identifier.
  'accountUsage': accountUsage_example, // {String} Filter the result.
  'verificationStatus': verificationStatus_example, // {String} Filter the result.
  'creditPaymentServiceName': creditPaymentServiceName_example // {String} This value will be used to filter the Payment Routes on Credit Payment Service Name
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new FeesApi();
            var paymentProviderName = paymentProviderName_example;  // String | The Payment Service Provider Name (default to null)
            var paymentAmount = 1.2;  // Double | The payment amount to calculate the fee. (default to null)
            var merchantGlobalID = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | The Merchant Tenant identifier. (optional)  (default to null)
            var accountUsage = accountUsage_example;  // String | Filter the result. (optional)  (default to supplier)
            var verificationStatus = verificationStatus_example;  // String | Filter the result. (optional)  (default to pending)
            var creditPaymentServiceName = creditPaymentServiceName_example;  // String | This value will be used to filter the Payment Routes on Credit Payment Service Name (optional)  (default to null)

            try {
                // Calculates fees payable.
                array[getAccountResponse] result = apiInstance.paymentAccountCalculateFee(paymentProviderName, paymentAmount, merchantGlobalID, accountUsage, verificationStatus, creditPaymentServiceName);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FeesApi.paymentAccountCalculateFee: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FeesApi();
$paymentProviderName = paymentProviderName_example; // String | The Payment Service Provider Name
$paymentAmount = 1.2; // Double | The payment amount to calculate the fee.
$merchantGlobalID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | The Merchant Tenant identifier.
$accountUsage = accountUsage_example; // String | Filter the result.
$verificationStatus = verificationStatus_example; // String | Filter the result.
$creditPaymentServiceName = creditPaymentServiceName_example; // String | This value will be used to filter the Payment Routes on Credit Payment Service Name

try {
    $result = $api_instance->paymentAccountCalculateFee($paymentProviderName, $paymentAmount, $merchantGlobalID, $accountUsage, $verificationStatus, $creditPaymentServiceName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FeesApi->paymentAccountCalculateFee: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FeesApi->new();
my $paymentProviderName = paymentProviderName_example; # String | The Payment Service Provider Name
my $paymentAmount = 1.2; # Double | The payment amount to calculate the fee.
my $merchantGlobalID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | The Merchant Tenant identifier.
my $accountUsage = accountUsage_example; # String | Filter the result.
my $verificationStatus = verificationStatus_example; # String | Filter the result.
my $creditPaymentServiceName = creditPaymentServiceName_example; # String | This value will be used to filter the Payment Routes on Credit Payment Service Name

eval {
    my $result = $api_instance->paymentAccountCalculateFee(paymentProviderName => $paymentProviderName, paymentAmount => $paymentAmount, merchantGlobalID => $merchantGlobalID, accountUsage => $accountUsage, verificationStatus => $verificationStatus, creditPaymentServiceName => $creditPaymentServiceName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FeesApi->paymentAccountCalculateFee: $@\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.FeesApi()
paymentProviderName = paymentProviderName_example # String | The Payment Service Provider Name (default to null)
paymentAmount = 1.2 # Double | The payment amount to calculate the fee. (default to null)
merchantGlobalID = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | The Merchant Tenant identifier. (optional) (default to null)
accountUsage = accountUsage_example # String | Filter the result. (optional) (default to supplier)
verificationStatus = verificationStatus_example # String | Filter the result. (optional) (default to pending)
creditPaymentServiceName = creditPaymentServiceName_example # String | This value will be used to filter the Payment Routes on Credit Payment Service Name (optional) (default to null)

try:
    # Calculates fees payable.
    api_response = api_instance.payment_account_calculate_fee(paymentProviderName, paymentAmount, merchantGlobalID=merchantGlobalID, accountUsage=accountUsage, verificationStatus=verificationStatus, creditPaymentServiceName=creditPaymentServiceName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FeesApi->paymentAccountCalculateFee: %s\n" % e)

extern crate FeesApi;

pub fn main() {
    let paymentProviderName = paymentProviderName_example; // String
    let paymentAmount = 1.2; // Double
    let merchantGlobalID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let accountUsage = accountUsage_example; // String
    let verificationStatus = verificationStatus_example; // String
    let creditPaymentServiceName = creditPaymentServiceName_example; // String

    let mut context = FeesApi::Context::default();
    let result = client.paymentAccountCalculateFee(paymentProviderName, paymentAmount, merchantGlobalID, accountUsage, verificationStatus, creditPaymentServiceName, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MerchantPaymentsApi apiInstance = new MerchantPaymentsApi();
        String paymentProviderName = paymentProviderName_example; // String | The Payment Service Provider Name
        Integer supplierID = 56; // Integer | ID of the customer's supplier
        String paymentMethod = paymentMethod_example; // String | The payment method used to process the payment.
        Double paymentAmount = 1.2; // Double | The payment amount to calculate the fee for.

        try {
            calculateFeeResponse result = apiInstance.merchantPaymentCalculateFee(paymentProviderName, supplierID, paymentMethod, paymentAmount);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MerchantPaymentsApi#merchantPaymentCalculateFee");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String paymentProviderName = new String(); // String | The Payment Service Provider Name
final Integer supplierID = new Integer(); // Integer | ID of the customer's supplier
final String paymentMethod = new String(); // String | The payment method used to process the payment.
final Double paymentAmount = new Double(); // Double | The payment amount to calculate the fee for.

try {
    final result = await api_instance.merchantPaymentCalculateFee(paymentProviderName, supplierID, paymentMethod, paymentAmount);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->merchantPaymentCalculateFee: $e\n');
}

import org.openapitools.client.api.MerchantPaymentsApi;

public class MerchantPaymentsApiExample {
    public static void main(String[] args) {
        MerchantPaymentsApi apiInstance = new MerchantPaymentsApi();
        String paymentProviderName = paymentProviderName_example; // String | The Payment Service Provider Name
        Integer supplierID = 56; // Integer | ID of the customer's supplier
        String paymentMethod = paymentMethod_example; // String | The payment method used to process the payment.
        Double paymentAmount = 1.2; // Double | The payment amount to calculate the fee for.

        try {
            calculateFeeResponse result = apiInstance.merchantPaymentCalculateFee(paymentProviderName, supplierID, paymentMethod, paymentAmount);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MerchantPaymentsApi#merchantPaymentCalculateFee");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
MerchantPaymentsApi *apiInstance = [[MerchantPaymentsApi alloc] init];
String *paymentProviderName = paymentProviderName_example; // The Payment Service Provider Name (default to null)
Integer *supplierID = 56; // ID of the customer's supplier (default to null)
String *paymentMethod = paymentMethod_example; // The payment method used to process the payment. (default to eftpos)
Double *paymentAmount = 1.2; // The payment amount to calculate the fee for. (default to null)

// Calculates fees payable by the buyer.
[apiInstance merchantPaymentCalculateFeeWith:paymentProviderName
    supplierID:supplierID
    paymentMethod:paymentMethod
    paymentAmount:paymentAmount
              completionHandler: ^(calculateFeeResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesPaymentServices = require('spenda_services_payment_services');

// Create an instance of the API class
var api = new SpendaServicesPaymentServices.MerchantPaymentsApi()
var paymentProviderName = paymentProviderName_example; // {String} The Payment Service Provider Name
var supplierID = 56; // {Integer} ID of the customer's supplier
var paymentMethod = paymentMethod_example; // {String} The payment method used to process the payment.
var paymentAmount = 1.2; // {Double} The payment amount to calculate the fee for.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.merchantPaymentCalculateFee(paymentProviderName, supplierID, paymentMethod, paymentAmount, callback);

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

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

            // Create an instance of the API class
            var apiInstance = new MerchantPaymentsApi();
            var paymentProviderName = paymentProviderName_example;  // String | The Payment Service Provider Name (default to null)
            var supplierID = 56;  // Integer | ID of the customer's supplier (default to null)
            var paymentMethod = paymentMethod_example;  // String | The payment method used to process the payment. (default to eftpos)
            var paymentAmount = 1.2;  // Double | The payment amount to calculate the fee for. (default to null)

            try {
                // Calculates fees payable by the buyer.
                calculateFeeResponse result = apiInstance.merchantPaymentCalculateFee(paymentProviderName, supplierID, paymentMethod, paymentAmount);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MerchantPaymentsApi.merchantPaymentCalculateFee: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MerchantPaymentsApi();
$paymentProviderName = paymentProviderName_example; // String | The Payment Service Provider Name
$supplierID = 56; // Integer | ID of the customer's supplier
$paymentMethod = paymentMethod_example; // String | The payment method used to process the payment.
$paymentAmount = 1.2; // Double | The payment amount to calculate the fee for.

try {
    $result = $api_instance->merchantPaymentCalculateFee($paymentProviderName, $supplierID, $paymentMethod, $paymentAmount);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MerchantPaymentsApi->merchantPaymentCalculateFee: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MerchantPaymentsApi->new();
my $paymentProviderName = paymentProviderName_example; # String | The Payment Service Provider Name
my $supplierID = 56; # Integer | ID of the customer's supplier
my $paymentMethod = paymentMethod_example; # String | The payment method used to process the payment.
my $paymentAmount = 1.2; # Double | The payment amount to calculate the fee for.

eval {
    my $result = $api_instance->merchantPaymentCalculateFee(paymentProviderName => $paymentProviderName, supplierID => $supplierID, paymentMethod => $paymentMethod, paymentAmount => $paymentAmount);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MerchantPaymentsApi->merchantPaymentCalculateFee: $@\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.MerchantPaymentsApi()
paymentProviderName = paymentProviderName_example # String | The Payment Service Provider Name (default to null)
supplierID = 56 # Integer | ID of the customer's supplier (default to null)
paymentMethod = paymentMethod_example # String | The payment method used to process the payment. (default to eftpos)
paymentAmount = 1.2 # Double | The payment amount to calculate the fee for. (default to null)

try:
    # Calculates fees payable by the buyer.
    api_response = api_instance.merchant_payment_calculate_fee(paymentProviderName, supplierID, paymentMethod, paymentAmount)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MerchantPaymentsApi->merchantPaymentCalculateFee: %s\n" % e)

extern crate MerchantPaymentsApi;

pub fn main() {
    let paymentProviderName = paymentProviderName_example; // String
    let supplierID = 56; // Integer
    let paymentMethod = paymentMethod_example; // String
    let paymentAmount = 1.2; // Double

    let mut context = MerchantPaymentsApi::Context::default();
    let result = client.merchantPaymentCalculateFee(paymentProviderName, supplierID, paymentMethod, paymentAmount, &context).wait();

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

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

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

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

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

        try {
            'String' result = apiInstance.merchantPaymentProcessBatchedTransactionsManualTrigger();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MerchantPaymentsApi#merchantPaymentProcessBatchedTransactionsManualTrigger");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.MerchantPaymentsApi;

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

        try {
            'String' result = apiInstance.merchantPaymentProcessBatchedTransactionsManualTrigger();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MerchantPaymentsApi#merchantPaymentProcessBatchedTransactionsManualTrigger");
            e.printStackTrace();
        }
    }
}

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

// Process batched transactions.
[apiInstance merchantPaymentProcessBatchedTransactionsManualTriggerWithCompletionHandler: 
              ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesPaymentServices = require('spenda_services_payment_services');

// Create an instance of the API class
var api = new SpendaServicesPaymentServices.MerchantPaymentsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.merchantPaymentProcessBatchedTransactionsManualTrigger(callback);

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

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

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

            try {
                // Process batched transactions.
                'String' result = apiInstance.merchantPaymentProcessBatchedTransactionsManualTrigger();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MerchantPaymentsApi.merchantPaymentProcessBatchedTransactionsManualTrigger: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Process batched transactions.
    api_response = api_instance.merchant_payment_process_batched_transactions_manual_trigger()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MerchantPaymentsApi->merchantPaymentProcessBatchedTransactionsManualTrigger: %s\n" % e)

extern crate MerchantPaymentsApi;

pub fn main() {

    let mut context = MerchantPaymentsApi::Context::default();
    let result = client.merchantPaymentProcessBatchedTransactionsManualTrigger(&context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.MerchantPaymentsApi;

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

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

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

// Trigger scheduled payments manually.
[apiInstance scheduledTransactionsNotificationManualTriggerWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesPaymentServices = require('spenda_services_payment_services');

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

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

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

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

            try {
                // Trigger scheduled payments manually.
                apiInstance.scheduledTransactionsNotificationManualTrigger();
            } catch (Exception e) {
                Debug.Print("Exception when calling MerchantPaymentsApi.scheduledTransactionsNotificationManualTrigger: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    $api_instance->scheduledTransactionsNotificationManualTrigger();
};
if ($@) {
    warn "Exception when calling MerchantPaymentsApi->scheduledTransactionsNotificationManualTrigger: $@\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.MerchantPaymentsApi()

try:
    # Trigger scheduled payments manually.
    api_instance.scheduled_transactions_notification_manual_trigger()
except ApiException as e:
    print("Exception when calling MerchantPaymentsApi->scheduledTransactionsNotificationManualTrigger: %s\n" % e)

extern crate MerchantPaymentsApi;

pub fn main() {

    let mut context = MerchantPaymentsApi::Context::default();
    let result = client.scheduledTransactionsNotificationManualTrigger(&context).wait();

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

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

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

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

        // Create an instance of the API class
        MerchantsApi apiInstance = new MerchantsApi();
        String paymentProviderName = paymentProviderName_example; // String | The Payment Service Provider Name
        String paymentServiceName = paymentServiceName_example; // String | The Payment Service Name
        Integer paymentMethodID = 56; // Integer | The Payment Service Name

        try {
            merchantResponse result = apiInstance.merchantGet(paymentProviderName, paymentServiceName, paymentMethodID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MerchantsApi#merchantGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String paymentProviderName = new String(); // String | The Payment Service Provider Name
final String paymentServiceName = new String(); // String | The Payment Service Name
final Integer paymentMethodID = new Integer(); // Integer | The Payment Service Name

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

import org.openapitools.client.api.MerchantsApi;

public class MerchantsApiExample {
    public static void main(String[] args) {
        MerchantsApi apiInstance = new MerchantsApi();
        String paymentProviderName = paymentProviderName_example; // String | The Payment Service Provider Name
        String paymentServiceName = paymentServiceName_example; // String | The Payment Service Name
        Integer paymentMethodID = 56; // Integer | The Payment Service Name

        try {
            merchantResponse result = apiInstance.merchantGet(paymentProviderName, paymentServiceName, paymentMethodID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MerchantsApi#merchantGet");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
MerchantsApi *apiInstance = [[MerchantsApi alloc] init];
String *paymentProviderName = paymentProviderName_example; // The Payment Service Provider Name (default to null)
String *paymentServiceName = paymentServiceName_example; // The Payment Service Name (default to null)
Integer *paymentMethodID = 56; // The Payment Service Name (default to null)

// Get a Payment Services Merchant
[apiInstance merchantGetWith:paymentProviderName
    paymentServiceName:paymentServiceName
    paymentMethodID:paymentMethodID
              completionHandler: ^(merchantResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesPaymentServices = require('spenda_services_payment_services');

// Create an instance of the API class
var api = new SpendaServicesPaymentServices.MerchantsApi()
var paymentProviderName = paymentProviderName_example; // {String} The Payment Service Provider Name
var paymentServiceName = paymentServiceName_example; // {String} The Payment Service Name
var paymentMethodID = 56; // {Integer} The Payment Service Name

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

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

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

            // Create an instance of the API class
            var apiInstance = new MerchantsApi();
            var paymentProviderName = paymentProviderName_example;  // String | The Payment Service Provider Name (default to null)
            var paymentServiceName = paymentServiceName_example;  // String | The Payment Service Name (default to null)
            var paymentMethodID = 56;  // Integer | The Payment Service Name (default to null)

            try {
                // Get a Payment Services Merchant
                merchantResponse result = apiInstance.merchantGet(paymentProviderName, paymentServiceName, paymentMethodID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MerchantsApi.merchantGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MerchantsApi();
$paymentProviderName = paymentProviderName_example; // String | The Payment Service Provider Name
$paymentServiceName = paymentServiceName_example; // String | The Payment Service Name
$paymentMethodID = 56; // Integer | The Payment Service Name

try {
    $result = $api_instance->merchantGet($paymentProviderName, $paymentServiceName, $paymentMethodID);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MerchantsApi->merchantGet: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MerchantsApi->new();
my $paymentProviderName = paymentProviderName_example; # String | The Payment Service Provider Name
my $paymentServiceName = paymentServiceName_example; # String | The Payment Service Name
my $paymentMethodID = 56; # Integer | The Payment Service Name

eval {
    my $result = $api_instance->merchantGet(paymentProviderName => $paymentProviderName, paymentServiceName => $paymentServiceName, paymentMethodID => $paymentMethodID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MerchantsApi->merchantGet: $@\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.MerchantsApi()
paymentProviderName = paymentProviderName_example # String | The Payment Service Provider Name (default to null)
paymentServiceName = paymentServiceName_example # String | The Payment Service Name (default to null)
paymentMethodID = 56 # Integer | The Payment Service Name (default to null)

try:
    # Get a Payment Services Merchant
    api_response = api_instance.merchant_get(paymentProviderName, paymentServiceName, paymentMethodID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MerchantsApi->merchantGet: %s\n" % e)

extern crate MerchantsApi;

pub fn main() {
    let paymentProviderName = paymentProviderName_example; // String
    let paymentServiceName = paymentServiceName_example; // String
    let paymentMethodID = 56; // Integer

    let mut context = MerchantsApi::Context::default();
    let result = client.merchantGet(paymentProviderName, paymentServiceName, paymentMethodID, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MerchantsApi apiInstance = new MerchantsApi();
        String paymentProviderName = paymentProviderName_example; // String | The Payment Service Provider Name
        UUID merchantGlobalID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | The Global ID of the Merchant Tenant

        try {
            getMerchantPaymentMethodsResponse result = apiInstance.merchantPaymentMethods(paymentProviderName, merchantGlobalID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MerchantsApi#merchantPaymentMethods");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String paymentProviderName = new String(); // String | The Payment Service Provider Name
final UUID merchantGlobalID = new UUID(); // UUID | The Global ID of the Merchant Tenant

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

import org.openapitools.client.api.MerchantsApi;

public class MerchantsApiExample {
    public static void main(String[] args) {
        MerchantsApi apiInstance = new MerchantsApi();
        String paymentProviderName = paymentProviderName_example; // String | The Payment Service Provider Name
        UUID merchantGlobalID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | The Global ID of the Merchant Tenant

        try {
            getMerchantPaymentMethodsResponse result = apiInstance.merchantPaymentMethods(paymentProviderName, merchantGlobalID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MerchantsApi#merchantPaymentMethods");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
MerchantsApi *apiInstance = [[MerchantsApi alloc] init];
String *paymentProviderName = paymentProviderName_example; // The Payment Service Provider Name (default to null)
UUID *merchantGlobalID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // The Global ID of the Merchant Tenant (default to null)

// Gets the Payment Methods supported by a Merchant
[apiInstance merchantPaymentMethodsWith:paymentProviderName
    merchantGlobalID:merchantGlobalID
              completionHandler: ^(getMerchantPaymentMethodsResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesPaymentServices = require('spenda_services_payment_services');

// Create an instance of the API class
var api = new SpendaServicesPaymentServices.MerchantsApi()
var paymentProviderName = paymentProviderName_example; // {String} The Payment Service Provider Name
var merchantGlobalID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} The Global ID of the Merchant Tenant

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

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

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

            // Create an instance of the API class
            var apiInstance = new MerchantsApi();
            var paymentProviderName = paymentProviderName_example;  // String | The Payment Service Provider Name (default to null)
            var merchantGlobalID = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | The Global ID of the Merchant Tenant (default to null)

            try {
                // Gets the Payment Methods supported by a Merchant
                getMerchantPaymentMethodsResponse result = apiInstance.merchantPaymentMethods(paymentProviderName, merchantGlobalID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MerchantsApi.merchantPaymentMethods: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MerchantsApi();
$paymentProviderName = paymentProviderName_example; // String | The Payment Service Provider Name
$merchantGlobalID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | The Global ID of the Merchant Tenant

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MerchantsApi->new();
my $paymentProviderName = paymentProviderName_example; # String | The Payment Service Provider Name
my $merchantGlobalID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | The Global ID of the Merchant Tenant

eval {
    my $result = $api_instance->merchantPaymentMethods(paymentProviderName => $paymentProviderName, merchantGlobalID => $merchantGlobalID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MerchantsApi->merchantPaymentMethods: $@\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.MerchantsApi()
paymentProviderName = paymentProviderName_example # String | The Payment Service Provider Name (default to null)
merchantGlobalID = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | The Global ID of the Merchant Tenant (default to null)

try:
    # Gets the Payment Methods supported by a Merchant
    api_response = api_instance.merchant_payment_methods(paymentProviderName, merchantGlobalID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MerchantsApi->merchantPaymentMethods: %s\n" % e)

extern crate MerchantsApi;

pub fn main() {
    let paymentProviderName = paymentProviderName_example; // String
    let merchantGlobalID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = MerchantsApi::Context::default();
    let result = client.merchantPaymentMethods(paymentProviderName, merchantGlobalID, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MerchantsApi apiInstance = new MerchantsApi();
        UpdateFeeRequest updateFeeRequest = {"paymentRouteID":0,"minimumFee":0,"maximumFee":0,"flatFee":0,"percentageFee":0,"payerFeePercentage":0}; // UpdateFeeRequest | 

        try {
            'Integer' result = apiInstance.merchantPaymentUpdateFees(updateFeeRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MerchantsApi#merchantPaymentUpdateFees");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UpdateFeeRequest updateFeeRequest = new UpdateFeeRequest(); // UpdateFeeRequest | 

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

import org.openapitools.client.api.MerchantsApi;

public class MerchantsApiExample {
    public static void main(String[] args) {
        MerchantsApi apiInstance = new MerchantsApi();
        UpdateFeeRequest updateFeeRequest = {"paymentRouteID":0,"minimumFee":0,"maximumFee":0,"flatFee":0,"percentageFee":0,"payerFeePercentage":0}; // UpdateFeeRequest | 

        try {
            'Integer' result = apiInstance.merchantPaymentUpdateFees(updateFeeRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MerchantsApi#merchantPaymentUpdateFees");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
MerchantsApi *apiInstance = [[MerchantsApi alloc] init];
UpdateFeeRequest *updateFeeRequest = {"paymentRouteID":0,"minimumFee":0,"maximumFee":0,"flatFee":0,"percentageFee":0,"payerFeePercentage":0}; //  (optional)

// Updates Merchant payment Fees.
[apiInstance merchantPaymentUpdateFeesWith:updateFeeRequest
              completionHandler: ^('Integer' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesPaymentServices = require('spenda_services_payment_services');

// Create an instance of the API class
var api = new SpendaServicesPaymentServices.MerchantsApi()
var opts = {
  'updateFeeRequest': {"paymentRouteID":0,"minimumFee":0,"maximumFee":0,"flatFee":0,"percentageFee":0,"payerFeePercentage":0} // {UpdateFeeRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new MerchantsApi();
            var updateFeeRequest = new UpdateFeeRequest(); // UpdateFeeRequest |  (optional) 

            try {
                // Updates Merchant payment Fees.
                'Integer' result = apiInstance.merchantPaymentUpdateFees(updateFeeRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MerchantsApi.merchantPaymentUpdateFees: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MerchantsApi();
$updateFeeRequest = {"paymentRouteID":0,"minimumFee":0,"maximumFee":0,"flatFee":0,"percentageFee":0,"payerFeePercentage":0}; // UpdateFeeRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MerchantsApi->new();
my $updateFeeRequest = WWW::OPenAPIClient::Object::UpdateFeeRequest->new(); # UpdateFeeRequest | 

eval {
    my $result = $api_instance->merchantPaymentUpdateFees(updateFeeRequest => $updateFeeRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MerchantsApi->merchantPaymentUpdateFees: $@\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.MerchantsApi()
updateFeeRequest = {"paymentRouteID":0,"minimumFee":0,"maximumFee":0,"flatFee":0,"percentageFee":0,"payerFeePercentage":0} # UpdateFeeRequest |  (optional)

try:
    # Updates Merchant payment Fees.
    api_response = api_instance.merchant_payment_update_fees(updateFeeRequest=updateFeeRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MerchantsApi->merchantPaymentUpdateFees: %s\n" % e)

extern crate MerchantsApi;

pub fn main() {
    let updateFeeRequest = {"paymentRouteID":0,"minimumFee":0,"maximumFee":0,"flatFee":0,"percentageFee":0,"payerFeePercentage":0}; // UpdateFeeRequest

    let mut context = MerchantsApi::Context::default();
    let result = client.merchantPaymentUpdateFees(updateFeeRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MerchantsApi apiInstance = new MerchantsApi();
        String paymentProviderName = paymentProviderName_example; // String | The Payment Service Provider Name
        String paymentServiceName = paymentServiceName_example; // String | The Payment Service Name
        Integer paymentMethodID = 56; // Integer | The Payment Service Name
        SaveMerchantRequest saveMerchantRequest = {"status":"Pending","isTermsAndConditionsAccepted":true,"deliveryMethod":"Consolidated","payerFeePercentage":0,"clearingAccountCode":"string"}; // SaveMerchantRequest | 

        try {
            merchantResponse result = apiInstance.merchantSave(paymentProviderName, paymentServiceName, paymentMethodID, saveMerchantRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MerchantsApi#merchantSave");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String paymentProviderName = new String(); // String | The Payment Service Provider Name
final String paymentServiceName = new String(); // String | The Payment Service Name
final Integer paymentMethodID = new Integer(); // Integer | The Payment Service Name
final SaveMerchantRequest saveMerchantRequest = new SaveMerchantRequest(); // SaveMerchantRequest | 

try {
    final result = await api_instance.merchantSave(paymentProviderName, paymentServiceName, paymentMethodID, saveMerchantRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->merchantSave: $e\n');
}

import org.openapitools.client.api.MerchantsApi;

public class MerchantsApiExample {
    public static void main(String[] args) {
        MerchantsApi apiInstance = new MerchantsApi();
        String paymentProviderName = paymentProviderName_example; // String | The Payment Service Provider Name
        String paymentServiceName = paymentServiceName_example; // String | The Payment Service Name
        Integer paymentMethodID = 56; // Integer | The Payment Service Name
        SaveMerchantRequest saveMerchantRequest = {"status":"Pending","isTermsAndConditionsAccepted":true,"deliveryMethod":"Consolidated","payerFeePercentage":0,"clearingAccountCode":"string"}; // SaveMerchantRequest | 

        try {
            merchantResponse result = apiInstance.merchantSave(paymentProviderName, paymentServiceName, paymentMethodID, saveMerchantRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MerchantsApi#merchantSave");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
MerchantsApi *apiInstance = [[MerchantsApi alloc] init];
String *paymentProviderName = paymentProviderName_example; // The Payment Service Provider Name (default to null)
String *paymentServiceName = paymentServiceName_example; // The Payment Service Name (default to null)
Integer *paymentMethodID = 56; // The Payment Service Name (default to null)
SaveMerchantRequest *saveMerchantRequest = {"status":"Pending","isTermsAndConditionsAccepted":true,"deliveryMethod":"Consolidated","payerFeePercentage":0,"clearingAccountCode":"string"}; //  (optional)

// Save a Payment Services Merchant
[apiInstance merchantSaveWith:paymentProviderName
    paymentServiceName:paymentServiceName
    paymentMethodID:paymentMethodID
    saveMerchantRequest:saveMerchantRequest
              completionHandler: ^(merchantResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesPaymentServices = require('spenda_services_payment_services');

// Create an instance of the API class
var api = new SpendaServicesPaymentServices.MerchantsApi()
var paymentProviderName = paymentProviderName_example; // {String} The Payment Service Provider Name
var paymentServiceName = paymentServiceName_example; // {String} The Payment Service Name
var paymentMethodID = 56; // {Integer} The Payment Service Name
var opts = {
  'saveMerchantRequest': {"status":"Pending","isTermsAndConditionsAccepted":true,"deliveryMethod":"Consolidated","payerFeePercentage":0,"clearingAccountCode":"string"} // {SaveMerchantRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new MerchantsApi();
            var paymentProviderName = paymentProviderName_example;  // String | The Payment Service Provider Name (default to null)
            var paymentServiceName = paymentServiceName_example;  // String | The Payment Service Name (default to null)
            var paymentMethodID = 56;  // Integer | The Payment Service Name (default to null)
            var saveMerchantRequest = new SaveMerchantRequest(); // SaveMerchantRequest |  (optional) 

            try {
                // Save a Payment Services Merchant
                merchantResponse result = apiInstance.merchantSave(paymentProviderName, paymentServiceName, paymentMethodID, saveMerchantRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MerchantsApi.merchantSave: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MerchantsApi();
$paymentProviderName = paymentProviderName_example; // String | The Payment Service Provider Name
$paymentServiceName = paymentServiceName_example; // String | The Payment Service Name
$paymentMethodID = 56; // Integer | The Payment Service Name
$saveMerchantRequest = {"status":"Pending","isTermsAndConditionsAccepted":true,"deliveryMethod":"Consolidated","payerFeePercentage":0,"clearingAccountCode":"string"}; // SaveMerchantRequest | 

try {
    $result = $api_instance->merchantSave($paymentProviderName, $paymentServiceName, $paymentMethodID, $saveMerchantRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MerchantsApi->merchantSave: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MerchantsApi->new();
my $paymentProviderName = paymentProviderName_example; # String | The Payment Service Provider Name
my $paymentServiceName = paymentServiceName_example; # String | The Payment Service Name
my $paymentMethodID = 56; # Integer | The Payment Service Name
my $saveMerchantRequest = WWW::OPenAPIClient::Object::SaveMerchantRequest->new(); # SaveMerchantRequest | 

eval {
    my $result = $api_instance->merchantSave(paymentProviderName => $paymentProviderName, paymentServiceName => $paymentServiceName, paymentMethodID => $paymentMethodID, saveMerchantRequest => $saveMerchantRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MerchantsApi->merchantSave: $@\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.MerchantsApi()
paymentProviderName = paymentProviderName_example # String | The Payment Service Provider Name (default to null)
paymentServiceName = paymentServiceName_example # String | The Payment Service Name (default to null)
paymentMethodID = 56 # Integer | The Payment Service Name (default to null)
saveMerchantRequest = {"status":"Pending","isTermsAndConditionsAccepted":true,"deliveryMethod":"Consolidated","payerFeePercentage":0,"clearingAccountCode":"string"} # SaveMerchantRequest |  (optional)

try:
    # Save a Payment Services Merchant
    api_response = api_instance.merchant_save(paymentProviderName, paymentServiceName, paymentMethodID, saveMerchantRequest=saveMerchantRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MerchantsApi->merchantSave: %s\n" % e)

extern crate MerchantsApi;

pub fn main() {
    let paymentProviderName = paymentProviderName_example; // String
    let paymentServiceName = paymentServiceName_example; // String
    let paymentMethodID = 56; // Integer
    let saveMerchantRequest = {"status":"Pending","isTermsAndConditionsAccepted":true,"deliveryMethod":"Consolidated","payerFeePercentage":0,"clearingAccountCode":"string"}; // SaveMerchantRequest

    let mut context = MerchantsApi::Context::default();
    let result = client.merchantSave(paymentProviderName, paymentServiceName, paymentMethodID, saveMerchantRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        NonMerchantPaymentsApi apiInstance = new NonMerchantPaymentsApi();
        String paymentProviderName = paymentProviderName_example; // String | The Payment Service Provider Name
        UUID paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Payment GUID.
        Double paymentAmount = 1.2; // Double | The payment amount to calculate the fee for.

        try {
            calculateFeeResponse result = apiInstance.nonMerchantPaymentCalculateFee(paymentProviderName, paymentAccountGUID, paymentAmount);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NonMerchantPaymentsApi#nonMerchantPaymentCalculateFee");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String paymentProviderName = new String(); // String | The Payment Service Provider Name
final UUID paymentAccountGUID = new UUID(); // UUID | Payment GUID.
final Double paymentAmount = new Double(); // Double | The payment amount to calculate the fee for.

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

import org.openapitools.client.api.NonMerchantPaymentsApi;

public class NonMerchantPaymentsApiExample {
    public static void main(String[] args) {
        NonMerchantPaymentsApi apiInstance = new NonMerchantPaymentsApi();
        String paymentProviderName = paymentProviderName_example; // String | The Payment Service Provider Name
        UUID paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Payment GUID.
        Double paymentAmount = 1.2; // Double | The payment amount to calculate the fee for.

        try {
            calculateFeeResponse result = apiInstance.nonMerchantPaymentCalculateFee(paymentProviderName, paymentAccountGUID, paymentAmount);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NonMerchantPaymentsApi#nonMerchantPaymentCalculateFee");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
NonMerchantPaymentsApi *apiInstance = [[NonMerchantPaymentsApi alloc] init];
String *paymentProviderName = paymentProviderName_example; // The Payment Service Provider Name (default to null)
UUID *paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // Payment GUID. (default to null)
Double *paymentAmount = 1.2; // The payment amount to calculate the fee for. (default to null)

// Calculates fees payable by the buyer.
[apiInstance nonMerchantPaymentCalculateFeeWith:paymentProviderName
    paymentAccountGUID:paymentAccountGUID
    paymentAmount:paymentAmount
              completionHandler: ^(calculateFeeResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesPaymentServices = require('spenda_services_payment_services');

// Create an instance of the API class
var api = new SpendaServicesPaymentServices.NonMerchantPaymentsApi()
var paymentProviderName = paymentProviderName_example; // {String} The Payment Service Provider Name
var paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} Payment GUID.
var paymentAmount = 1.2; // {Double} The payment amount to calculate the fee for.

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

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

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

            // Create an instance of the API class
            var apiInstance = new NonMerchantPaymentsApi();
            var paymentProviderName = paymentProviderName_example;  // String | The Payment Service Provider Name (default to null)
            var paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | Payment GUID. (default to null)
            var paymentAmount = 1.2;  // Double | The payment amount to calculate the fee for. (default to null)

            try {
                // Calculates fees payable by the buyer.
                calculateFeeResponse result = apiInstance.nonMerchantPaymentCalculateFee(paymentProviderName, paymentAccountGUID, paymentAmount);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling NonMerchantPaymentsApi.nonMerchantPaymentCalculateFee: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\NonMerchantPaymentsApi();
$paymentProviderName = paymentProviderName_example; // String | The Payment Service Provider Name
$paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Payment GUID.
$paymentAmount = 1.2; // Double | The payment amount to calculate the fee for.

try {
    $result = $api_instance->nonMerchantPaymentCalculateFee($paymentProviderName, $paymentAccountGUID, $paymentAmount);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling NonMerchantPaymentsApi->nonMerchantPaymentCalculateFee: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::NonMerchantPaymentsApi->new();
my $paymentProviderName = paymentProviderName_example; # String | The Payment Service Provider Name
my $paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | Payment GUID.
my $paymentAmount = 1.2; # Double | The payment amount to calculate the fee for.

eval {
    my $result = $api_instance->nonMerchantPaymentCalculateFee(paymentProviderName => $paymentProviderName, paymentAccountGUID => $paymentAccountGUID, paymentAmount => $paymentAmount);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling NonMerchantPaymentsApi->nonMerchantPaymentCalculateFee: $@\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.NonMerchantPaymentsApi()
paymentProviderName = paymentProviderName_example # String | The Payment Service Provider Name (default to null)
paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | Payment GUID. (default to null)
paymentAmount = 1.2 # Double | The payment amount to calculate the fee for. (default to null)

try:
    # Calculates fees payable by the buyer.
    api_response = api_instance.non_merchant_payment_calculate_fee(paymentProviderName, paymentAccountGUID, paymentAmount)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NonMerchantPaymentsApi->nonMerchantPaymentCalculateFee: %s\n" % e)

extern crate NonMerchantPaymentsApi;

pub fn main() {
    let paymentProviderName = paymentProviderName_example; // String
    let paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let paymentAmount = 1.2; // Double

    let mut context = NonMerchantPaymentsApi::Context::default();
    let result = client.nonMerchantPaymentCalculateFee(paymentProviderName, paymentAccountGUID, paymentAmount, &context).wait();

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.NonMerchantPaymentsApi;

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

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

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

// Trigger scheduled payments manually.
[apiInstance scheduledTransactionsNotificationManualTriggerWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesPaymentServices = require('spenda_services_payment_services');

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

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

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

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

            try {
                // Trigger scheduled payments manually.
                apiInstance.scheduledTransactionsNotificationManualTrigger();
            } catch (Exception e) {
                Debug.Print("Exception when calling NonMerchantPaymentsApi.scheduledTransactionsNotificationManualTrigger: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    $api_instance->scheduledTransactionsNotificationManualTrigger();
};
if ($@) {
    warn "Exception when calling NonMerchantPaymentsApi->scheduledTransactionsNotificationManualTrigger: $@\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.NonMerchantPaymentsApi()

try:
    # Trigger scheduled payments manually.
    api_instance.scheduled_transactions_notification_manual_trigger()
except ApiException as e:
    print("Exception when calling NonMerchantPaymentsApi->scheduledTransactionsNotificationManualTrigger: %s\n" % e)

extern crate NonMerchantPaymentsApi;

pub fn main() {

    let mut context = NonMerchantPaymentsApi::Context::default();
    let result = client.scheduledTransactionsNotificationManualTrigger(&context).wait();

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