Spenda.Services.Fiserv

Accounts

accountNew

Registers a new Account for the calling user

Creates a new Fiserv Account, storing the card details for use later.

/PaymentServices/CreditCard/Account/{paymentProvider}

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.dev.spenda.co/api/PaymentServices/CreditCard/Account/{paymentProvider}" \
 -d ''

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 paymentProvider = paymentProvider_example; // String | Identifier of the Payment Services Provider the account belongs to
        NewFiservAccountRequest newFiservAccountRequest = {"cardholderName":"string","cardType":"string","cardNumber":"string","expiry":"string","ccv":"string","isSingleUse":true,"friendlyName":"string","merchantTenantGlobalID":"string"}; // NewFiservAccountRequest | 

        try {
            newFiservAccountResponse result = apiInstance.accountNew(paymentProvider, newFiservAccountRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#accountNew");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String paymentProvider = new String(); // String | Identifier of the Payment Services Provider the account belongs to
final NewFiservAccountRequest newFiservAccountRequest = new NewFiservAccountRequest(); // NewFiservAccountRequest | 

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

import org.openapitools.client.api.AccountsApi;

public class AccountsApiExample {
    public static void main(String[] args) {
        AccountsApi apiInstance = new AccountsApi();
        String paymentProvider = paymentProvider_example; // String | Identifier of the Payment Services Provider the account belongs to
        NewFiservAccountRequest newFiservAccountRequest = {"cardholderName":"string","cardType":"string","cardNumber":"string","expiry":"string","ccv":"string","isSingleUse":true,"friendlyName":"string","merchantTenantGlobalID":"string"}; // NewFiservAccountRequest | 

        try {
            newFiservAccountResponse result = apiInstance.accountNew(paymentProvider, newFiservAccountRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#accountNew");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AccountsApi *apiInstance = [[AccountsApi alloc] init];
String *paymentProvider = paymentProvider_example; // Identifier of the Payment Services Provider the account belongs to (default to null)
NewFiservAccountRequest *newFiservAccountRequest = {"cardholderName":"string","cardType":"string","cardNumber":"string","expiry":"string","ccv":"string","isSingleUse":true,"friendlyName":"string","merchantTenantGlobalID":"string"}; //  (optional)

// Registers a new Account for the calling user
[apiInstance accountNewWith:paymentProvider
    newFiservAccountRequest:newFiservAccountRequest
              completionHandler: ^(newFiservAccountResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesFiserv = require('spenda_services_fiserv');

// Create an instance of the API class
var api = new SpendaServicesFiserv.AccountsApi()
var paymentProvider = paymentProvider_example; // {String} Identifier of the Payment Services Provider the account belongs to
var opts = {
  'newFiservAccountRequest': {"cardholderName":"string","cardType":"string","cardNumber":"string","expiry":"string","ccv":"string","isSingleUse":true,"friendlyName":"string","merchantTenantGlobalID":"string"} // {NewFiservAccountRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new AccountsApi();
            var paymentProvider = paymentProvider_example;  // String | Identifier of the Payment Services Provider the account belongs to (default to null)
            var newFiservAccountRequest = new NewFiservAccountRequest(); // NewFiservAccountRequest |  (optional) 

            try {
                // Registers a new Account for the calling user
                newFiservAccountResponse result = apiInstance.accountNew(paymentProvider, newFiservAccountRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsApi.accountNew: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccountsApi();
$paymentProvider = paymentProvider_example; // String | Identifier of the Payment Services Provider the account belongs to
$newFiservAccountRequest = {"cardholderName":"string","cardType":"string","cardNumber":"string","expiry":"string","ccv":"string","isSingleUse":true,"friendlyName":"string","merchantTenantGlobalID":"string"}; // NewFiservAccountRequest | 

try {
    $result = $api_instance->accountNew($paymentProvider, $newFiservAccountRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AccountsApi->accountNew: ', $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 $paymentProvider = paymentProvider_example; # String | Identifier of the Payment Services Provider the account belongs to
my $newFiservAccountRequest = WWW::OPenAPIClient::Object::NewFiservAccountRequest->new(); # NewFiservAccountRequest | 

eval {
    my $result = $api_instance->accountNew(paymentProvider => $paymentProvider, newFiservAccountRequest => $newFiservAccountRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountsApi->accountNew: $@\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()
paymentProvider = paymentProvider_example # String | Identifier of the Payment Services Provider the account belongs to (default to null)
newFiservAccountRequest = {"cardholderName":"string","cardType":"string","cardNumber":"string","expiry":"string","ccv":"string","isSingleUse":true,"friendlyName":"string","merchantTenantGlobalID":"string"} # NewFiservAccountRequest |  (optional)

try:
    # Registers a new Account for the calling user
    api_response = api_instance.account_new(paymentProvider, newFiservAccountRequest=newFiservAccountRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsApi->accountNew: %s\n" % e)

extern crate AccountsApi;

pub fn main() {
    let paymentProvider = paymentProvider_example; // String
    let newFiservAccountRequest = {"cardholderName":"string","cardType":"string","cardNumber":"string","expiry":"string","ccv":"string","isSingleUse":true,"friendlyName":"string","merchantTenantGlobalID":"string"}; // NewFiservAccountRequest

    let mut context = AccountsApi::Context::default();
    let result = client.accountNew(paymentProvider, newFiservAccountRequest, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
paymentProvider*	String Identifier of the Payment Services Provider the account belongs to Required

Body parameters

Name	Description
newFiservAccountRequest

Responses

Schema

airPlusAccountDBIConfig

Get AirPlus Account DBI Configuration

Get AirPlus Account DBI Configuration.

/PaymentServices/CreditCard/Account/{paymentProvider}/AirPlus/{paymentAccountGUID}/DBIConfig

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "https://api.dev.spenda.co/api/PaymentServices/CreditCard/Account/{paymentProvider}/AirPlus/{paymentAccountGUID}/DBIConfig"

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 paymentProvider = paymentProvider_example; // String | Identifier of the Payment Services Provider the account belongs to
        UUID paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Payment Account identifier

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.AccountsApi;

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

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



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

// Get AirPlus Account DBI Configuration
[apiInstance airPlusAccountDBIConfigWith:paymentProvider
    paymentAccountGUID:paymentAccountGUID
              completionHandler: ^(airPlusAccountDBIConfigResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesFiserv = require('spenda_services_fiserv');

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

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

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

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

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

            try {
                // Get AirPlus Account DBI Configuration
                airPlusAccountDBIConfigResponse result = apiInstance.airPlusAccountDBIConfig(paymentProvider, paymentAccountGUID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsApi.airPlusAccountDBIConfig: " + e.Message );
            }
        }
    }
}

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

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

try {
    $result = $api_instance->airPlusAccountDBIConfig($paymentProvider, $paymentAccountGUID);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AccountsApi->airPlusAccountDBIConfig: ', $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 $paymentProvider = paymentProvider_example; # String | Identifier of the Payment Services Provider the account belongs to
my $paymentAccountGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | Payment Account identifier

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

try:
    # Get AirPlus Account DBI Configuration
    api_response = api_instance.air_plus_account_dbi_config(paymentProvider, paymentAccountGUID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsApi->airPlusAccountDBIConfig: %s\n" % e)

extern crate AccountsApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
paymentProvider*	String Identifier of the Payment Services Provider the account belongs to Required
paymentAccountGUID*	UUID (uuid) Payment Account identifier Required

Responses

Schema

airPlusAccountNew

Registers a new AirPlus Account for the calling user

Creates a new AirPlus Account, storing the AirPlus member details for use later.

/PaymentServices/CreditCard/Account/{paymentProvider}/AirPlus

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.dev.spenda.co/api/PaymentServices/CreditCard/Account/{paymentProvider}/AirPlus" \
 -d ''

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 paymentProvider = paymentProvider_example; // String | Identifier of the Payment Services Provider the account belongs to
        AirPlusAccountRequest airPlusAccountRequest = {"memberNumber":"string","friendlyName":"string"}; // AirPlusAccountRequest | 

        try {
            airPlusAccountResponse result = apiInstance.airPlusAccountNew(paymentProvider, airPlusAccountRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#airPlusAccountNew");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String paymentProvider = new String(); // String | Identifier of the Payment Services Provider the account belongs to
final AirPlusAccountRequest airPlusAccountRequest = new AirPlusAccountRequest(); // AirPlusAccountRequest | 

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

import org.openapitools.client.api.AccountsApi;

public class AccountsApiExample {
    public static void main(String[] args) {
        AccountsApi apiInstance = new AccountsApi();
        String paymentProvider = paymentProvider_example; // String | Identifier of the Payment Services Provider the account belongs to
        AirPlusAccountRequest airPlusAccountRequest = {"memberNumber":"string","friendlyName":"string"}; // AirPlusAccountRequest | 

        try {
            airPlusAccountResponse result = apiInstance.airPlusAccountNew(paymentProvider, airPlusAccountRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#airPlusAccountNew");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AccountsApi *apiInstance = [[AccountsApi alloc] init];
String *paymentProvider = paymentProvider_example; // Identifier of the Payment Services Provider the account belongs to (default to null)
AirPlusAccountRequest *airPlusAccountRequest = {"memberNumber":"string","friendlyName":"string"}; //  (optional)

// Registers a new AirPlus Account for the calling user
[apiInstance airPlusAccountNewWith:paymentProvider
    airPlusAccountRequest:airPlusAccountRequest
              completionHandler: ^(airPlusAccountResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesFiserv = require('spenda_services_fiserv');

// Create an instance of the API class
var api = new SpendaServicesFiserv.AccountsApi()
var paymentProvider = paymentProvider_example; // {String} Identifier of the Payment Services Provider the account belongs to
var opts = {
  'airPlusAccountRequest': {"memberNumber":"string","friendlyName":"string"} // {AirPlusAccountRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new AccountsApi();
            var paymentProvider = paymentProvider_example;  // String | Identifier of the Payment Services Provider the account belongs to (default to null)
            var airPlusAccountRequest = new AirPlusAccountRequest(); // AirPlusAccountRequest |  (optional) 

            try {
                // Registers a new AirPlus Account for the calling user
                airPlusAccountResponse result = apiInstance.airPlusAccountNew(paymentProvider, airPlusAccountRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsApi.airPlusAccountNew: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccountsApi();
$paymentProvider = paymentProvider_example; // String | Identifier of the Payment Services Provider the account belongs to
$airPlusAccountRequest = {"memberNumber":"string","friendlyName":"string"}; // AirPlusAccountRequest | 

try {
    $result = $api_instance->airPlusAccountNew($paymentProvider, $airPlusAccountRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AccountsApi->airPlusAccountNew: ', $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 $paymentProvider = paymentProvider_example; # String | Identifier of the Payment Services Provider the account belongs to
my $airPlusAccountRequest = WWW::OPenAPIClient::Object::AirPlusAccountRequest->new(); # AirPlusAccountRequest | 

eval {
    my $result = $api_instance->airPlusAccountNew(paymentProvider => $paymentProvider, airPlusAccountRequest => $airPlusAccountRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountsApi->airPlusAccountNew: $@\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()
paymentProvider = paymentProvider_example # String | Identifier of the Payment Services Provider the account belongs to (default to null)
airPlusAccountRequest = {"memberNumber":"string","friendlyName":"string"} # AirPlusAccountRequest |  (optional)

try:
    # Registers a new AirPlus Account for the calling user
    api_response = api_instance.air_plus_account_new(paymentProvider, airPlusAccountRequest=airPlusAccountRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsApi->airPlusAccountNew: %s\n" % e)

extern crate AccountsApi;

pub fn main() {
    let paymentProvider = paymentProvider_example; // String
    let airPlusAccountRequest = {"memberNumber":"string","friendlyName":"string"}; // AirPlusAccountRequest

    let mut context = AccountsApi::Context::default();
    let result = client.airPlusAccountNew(paymentProvider, airPlusAccountRequest, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
paymentProvider*	String Identifier of the Payment Services Provider the account belongs to Required

Body parameters

Name	Description
airPlusAccountRequest

Responses

Schema

Transactions

dataMeshTransactionImports

Import transaction

/PaymentServices/CreditCard/Import/Transactions

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 "https://api.dev.spenda.co/api/PaymentServices/CreditCard/Import/Transactions"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.TransactionsApi;

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

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



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

// Import transaction
[apiInstance dataMeshTransactionImportsWithCompletionHandler: 
              ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesFiserv = require('spenda_services_fiserv');

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

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

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

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

            try {
                // Import transaction
                'String' result = apiInstance.dataMeshTransactionImports();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TransactionsApi.dataMeshTransactionImports: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Import transaction
    api_response = api_instance.data_mesh_transaction_imports()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TransactionsApi->dataMeshTransactionImports: %s\n" % e)

extern crate TransactionsApi;

pub fn main() {

    let mut context = TransactionsApi::Context::default();
    let result = client.dataMeshTransactionImports(&context).wait();

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

Scopes

Parameters

Responses

Schema

mastercardBPSPSettlementImport

Import transaction settlement

/PaymentServices/CreditCard/Settlement/{paymentProvider}

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 "https://api.dev.spenda.co/api/PaymentServices/CreditCard/Settlement/{paymentProvider}"

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

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

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

        // Create an instance of the API class
        TransactionsApi apiInstance = new TransactionsApi();
        String paymentProvider = paymentProvider_example; // String | Imports transaction settlement

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String paymentProvider = new String(); // String | Imports transaction settlement

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

import org.openapitools.client.api.TransactionsApi;

public class TransactionsApiExample {
    public static void main(String[] args) {
        TransactionsApi apiInstance = new TransactionsApi();
        String paymentProvider = paymentProvider_example; // String | Imports transaction settlement

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



// Create an instance of the API class
TransactionsApi *apiInstance = [[TransactionsApi alloc] init];
String *paymentProvider = paymentProvider_example; // Imports transaction settlement (default to null)

// Import transaction settlement
[apiInstance mastercardBPSPSettlementImportWith:paymentProvider
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesFiserv = require('spenda_services_fiserv');

// Create an instance of the API class
var api = new SpendaServicesFiserv.TransactionsApi()
var paymentProvider = paymentProvider_example; // {String} Imports transaction settlement

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

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

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

            // Create an instance of the API class
            var apiInstance = new TransactionsApi();
            var paymentProvider = paymentProvider_example;  // String | Imports transaction settlement (default to null)

            try {
                // Import transaction settlement
                'String' result = apiInstance.mastercardBPSPSettlementImport(paymentProvider);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TransactionsApi.mastercardBPSPSettlementImport: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TransactionsApi();
$paymentProvider = paymentProvider_example; // String | Imports transaction settlement

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TransactionsApi->new();
my $paymentProvider = paymentProvider_example; # String | Imports transaction settlement

eval {
    my $result = $api_instance->mastercardBPSPSettlementImport(paymentProvider => $paymentProvider);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TransactionsApi->mastercardBPSPSettlementImport: $@\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.TransactionsApi()
paymentProvider = paymentProvider_example # String | Imports transaction settlement (default to null)

try:
    # Import transaction settlement
    api_response = api_instance.mastercard_bpsp_settlement_import(paymentProvider)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TransactionsApi->mastercardBPSPSettlementImport: %s\n" % e)

extern crate TransactionsApi;

pub fn main() {
    let paymentProvider = paymentProvider_example; // String

    let mut context = TransactionsApi::Context::default();
    let result = client.mastercardBPSPSettlementImport(paymentProvider, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
paymentProvider*	String Imports transaction settlement Required

Responses

Schema

payFacTerminalTransactionSubmitManualTrigger

Import transaction settlement

/PaymentServices/CreditCard/PayFacTerminalTransactionSubmitManualTrigger

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 "https://api.dev.spenda.co/api/PaymentServices/CreditCard/PayFacTerminalTransactionSubmitManualTrigger"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.TransactionsApi;

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

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



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

// Import transaction settlement
[apiInstance payFacTerminalTransactionSubmitManualTriggerWithCompletionHandler: 
              ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesFiserv = require('spenda_services_fiserv');

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

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

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

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

            try {
                // Import transaction settlement
                'String' result = apiInstance.payFacTerminalTransactionSubmitManualTrigger();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TransactionsApi.payFacTerminalTransactionSubmitManualTrigger: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Import transaction settlement
    api_response = api_instance.pay_fac_terminal_transaction_submit_manual_trigger()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TransactionsApi->payFacTerminalTransactionSubmitManualTrigger: %s\n" % e)

extern crate TransactionsApi;

pub fn main() {

    let mut context = TransactionsApi::Context::default();
    let result = client.payFacTerminalTransactionSubmitManualTrigger(&context).wait();

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

Scopes

Parameters

Responses

Schema

Spenda.Services.Fiserv

API and SDK Documentation

Accounts

accountNew

Usage and SDK Samples

Scopes

Parameters

Responses

airPlusAccountDBIConfig

Usage and SDK Samples

Scopes

Parameters

Responses

airPlusAccountNew

Usage and SDK Samples

Scopes

Parameters

Responses

Transactions

dataMeshTransactionImports

Usage and SDK Samples

Scopes

Parameters

Responses

mastercardBPSPSettlementImport

Usage and SDK Samples

Scopes

Parameters

Responses

payFacTerminalTransactionSubmitManualTrigger

Usage and SDK Samples

Scopes

Parameters

Responses