Spenda API

AccountsPayable

aPGETAgedPayables

AP_GET_AgedPayables

Gets a collection of Transactions - Purchase Invoices, Credit Notes and Unallocated Payments - grouped by Supplier, that can be used for constructing Payment Batches.


/v3/ap/agedPayables

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,application/problem+json" \
 "https://api.dev.spenda.co/api/v3/ap/agedPayables"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountsPayableApi;

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

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

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

        try {
            AgedPayables result = apiInstance.aPGETAgedPayables();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETAgedPayables");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.AccountsPayableApi;

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

        try {
            AgedPayables result = apiInstance.aPGETAgedPayables();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETAgedPayables");
            e.printStackTrace();
        }
    }
}


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

// AP_GET_AgedPayables
[apiInstance aPGETAgedPayablesWithCompletionHandler: 
              ^(AgedPayables output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.AccountsPayableApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.aPGETAgedPayables(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                // AP_GET_AgedPayables
                AgedPayables result = apiInstance.aPGETAgedPayables();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsPayableApi.aPGETAgedPayables: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # AP_GET_AgedPayables
    api_response = api_instance.a_pget_aged_payables()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsPayableApi->aPGETAgedPayables: %s\n" % e)
extern crate AccountsPayableApi;

pub fn main() {

    let mut context = AccountsPayableApi::Context::default();
    let result = client.aPGETAgedPayables(&context).wait();

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

Scopes

Parameters

Responses


aPGETBatch

AP_GET_Batch

Get a single AP batch by identifier.


/v3/ap/batches/{batchGuid}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,application/problem+json" \
 "https://api.dev.spenda.co/api/v3/ap/batches/{batchGuid}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountsPayableApi;

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

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

        // Create an instance of the API class
        AccountsPayableApi apiInstance = new AccountsPayableApi();
        UUID batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            Batch result = apiInstance.aPGETBatch(batchGuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETBatch");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID batchGuid = new UUID(); // UUID | 

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

import org.openapitools.client.api.AccountsPayableApi;

public class AccountsPayableApiExample {
    public static void main(String[] args) {
        AccountsPayableApi apiInstance = new AccountsPayableApi();
        UUID batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            Batch result = apiInstance.aPGETBatch(batchGuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETBatch");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
AccountsPayableApi *apiInstance = [[AccountsPayableApi alloc] init];
UUID *batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// AP_GET_Batch
[apiInstance aPGETBatchWith:batchGuid
              completionHandler: ^(Batch output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.AccountsPayableApi()
var batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.aPGETBatch(batchGuid, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AccountsPayableApi();
            var batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // AP_GET_Batch
                Batch result = apiInstance.aPGETBatch(batchGuid);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsPayableApi.aPGETBatch: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccountsPayableApi();
$batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AccountsPayableApi->new();
my $batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->aPGETBatch(batchGuid => $batchGuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountsPayableApi->aPGETBatch: $@\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.AccountsPayableApi()
batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # AP_GET_Batch
    api_response = api_instance.a_pget_batch(batchGuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsPayableApi->aPGETBatch: %s\n" % e)
extern crate AccountsPayableApi;

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

    let mut context = AccountsPayableApi::Context::default();
    let result = client.aPGETBatch(batchGuid, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
batchGuid*
UUID (uuid)
Required

Responses


aPGETBatches

AP_GET_Batches

Get a collection of AP batches


/v3/ap/batches

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,application/problem+json" \
 "https://api.dev.spenda.co/api/v3/ap/batches?statuses=&paymentAccountGuid=38400000-8cf0-11bd-b23e-10b96e4ef00d&createdFromDate=2013-10-20&createdToDate=2013-10-20&searchString=searchString_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountsPayableApi;

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

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

        // Create an instance of the API class
        AccountsPayableApi apiInstance = new AccountsPayableApi();
        array[PaymentBatchStatus] statuses = ; // array[PaymentBatchStatus] | 
        UUID paymentAccountGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        date createdFromDate = 2013-10-20; // date | 
        date createdToDate = 2013-10-20; // date | 
        String searchString = searchString_example; // String | 

        try {
            Batches result = apiInstance.aPGETBatches(statuses, paymentAccountGuid, createdFromDate, createdToDate, searchString);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETBatches");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[PaymentBatchStatus] statuses = new array[PaymentBatchStatus](); // array[PaymentBatchStatus] | 
final UUID paymentAccountGuid = new UUID(); // UUID | 
final date createdFromDate = new date(); // date | 
final date createdToDate = new date(); // date | 
final String searchString = new String(); // String | 

try {
    final result = await api_instance.aPGETBatches(statuses, paymentAccountGuid, createdFromDate, createdToDate, searchString);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->aPGETBatches: $e\n');
}

import org.openapitools.client.api.AccountsPayableApi;

public class AccountsPayableApiExample {
    public static void main(String[] args) {
        AccountsPayableApi apiInstance = new AccountsPayableApi();
        array[PaymentBatchStatus] statuses = ; // array[PaymentBatchStatus] | 
        UUID paymentAccountGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        date createdFromDate = 2013-10-20; // date | 
        date createdToDate = 2013-10-20; // date | 
        String searchString = searchString_example; // String | 

        try {
            Batches result = apiInstance.aPGETBatches(statuses, paymentAccountGuid, createdFromDate, createdToDate, searchString);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETBatches");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
AccountsPayableApi *apiInstance = [[AccountsPayableApi alloc] init];
array[PaymentBatchStatus] *statuses = ; //  (optional) (default to null)
UUID *paymentAccountGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (optional) (default to null)
date *createdFromDate = 2013-10-20; //  (optional) (default to null)
date *createdToDate = 2013-10-20; //  (optional) (default to null)
String *searchString = searchString_example; //  (optional) (default to null)

// AP_GET_Batches
[apiInstance aPGETBatchesWith:statuses
    paymentAccountGuid:paymentAccountGuid
    createdFromDate:createdFromDate
    createdToDate:createdToDate
    searchString:searchString
              completionHandler: ^(Batches output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.AccountsPayableApi()
var opts = {
  'statuses': , // {array[PaymentBatchStatus]} 
  'paymentAccountGuid': 38400000-8cf0-11bd-b23e-10b96e4ef00d, // {UUID} 
  'createdFromDate': 2013-10-20, // {date} 
  'createdToDate': 2013-10-20, // {date} 
  'searchString': searchString_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.aPGETBatches(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AccountsPayableApi();
            var statuses = new array[PaymentBatchStatus](); // array[PaymentBatchStatus] |  (optional)  (default to null)
            var paymentAccountGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (optional)  (default to null)
            var createdFromDate = 2013-10-20;  // date |  (optional)  (default to null)
            var createdToDate = 2013-10-20;  // date |  (optional)  (default to null)
            var searchString = searchString_example;  // String |  (optional)  (default to null)

            try {
                // AP_GET_Batches
                Batches result = apiInstance.aPGETBatches(statuses, paymentAccountGuid, createdFromDate, createdToDate, searchString);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsPayableApi.aPGETBatches: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccountsPayableApi();
$statuses = ; // array[PaymentBatchStatus] | 
$paymentAccountGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$createdFromDate = 2013-10-20; // date | 
$createdToDate = 2013-10-20; // date | 
$searchString = searchString_example; // String | 

try {
    $result = $api_instance->aPGETBatches($statuses, $paymentAccountGuid, $createdFromDate, $createdToDate, $searchString);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AccountsPayableApi->aPGETBatches: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AccountsPayableApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AccountsPayableApi->new();
my $statuses = []; # array[PaymentBatchStatus] | 
my $paymentAccountGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $createdFromDate = 2013-10-20; # date | 
my $createdToDate = 2013-10-20; # date | 
my $searchString = searchString_example; # String | 

eval {
    my $result = $api_instance->aPGETBatches(statuses => $statuses, paymentAccountGuid => $paymentAccountGuid, createdFromDate => $createdFromDate, createdToDate => $createdToDate, searchString => $searchString);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountsPayableApi->aPGETBatches: $@\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.AccountsPayableApi()
statuses =  # array[PaymentBatchStatus] |  (optional) (default to null)
paymentAccountGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (optional) (default to null)
createdFromDate = 2013-10-20 # date |  (optional) (default to null)
createdToDate = 2013-10-20 # date |  (optional) (default to null)
searchString = searchString_example # String |  (optional) (default to null)

try:
    # AP_GET_Batches
    api_response = api_instance.a_pget_batches(statuses=statuses, paymentAccountGuid=paymentAccountGuid, createdFromDate=createdFromDate, createdToDate=createdToDate, searchString=searchString)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsPayableApi->aPGETBatches: %s\n" % e)
extern crate AccountsPayableApi;

pub fn main() {
    let statuses = ; // array[PaymentBatchStatus]
    let paymentAccountGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let createdFromDate = 2013-10-20; // date
    let createdToDate = 2013-10-20; // date
    let searchString = searchString_example; // String

    let mut context = AccountsPayableApi::Context::default();
    let result = client.aPGETBatches(statuses, paymentAccountGuid, createdFromDate, createdToDate, searchString, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
statuses
array[PaymentBatchStatus]
paymentAccountGuid
UUID (uuid)
createdFromDate
date (date)
createdToDate
date (date)
searchString
String

Responses


aPGETCreditNote

AP_GET_CreditNote

Get a single Credit Note by identifier.


/v3/ap/creditNotes/{creditNoteGUID}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,application/problem+json" \
 "https://api.dev.spenda.co/api/v3/ap/creditNotes/{creditNoteGUID}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountsPayableApi;

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

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

        // Create an instance of the API class
        AccountsPayableApi apiInstance = new AccountsPayableApi();
        UUID creditNoteGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            CreditNote result = apiInstance.aPGETCreditNote(creditNoteGUID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETCreditNote");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID creditNoteGUID = new UUID(); // UUID | 

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

import org.openapitools.client.api.AccountsPayableApi;

public class AccountsPayableApiExample {
    public static void main(String[] args) {
        AccountsPayableApi apiInstance = new AccountsPayableApi();
        UUID creditNoteGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            CreditNote result = apiInstance.aPGETCreditNote(creditNoteGUID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETCreditNote");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
AccountsPayableApi *apiInstance = [[AccountsPayableApi alloc] init];
UUID *creditNoteGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// AP_GET_CreditNote
[apiInstance aPGETCreditNoteWith:creditNoteGUID
              completionHandler: ^(CreditNote output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.AccountsPayableApi()
var creditNoteGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.aPGETCreditNote(creditNoteGUID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AccountsPayableApi();
            var creditNoteGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // AP_GET_CreditNote
                CreditNote result = apiInstance.aPGETCreditNote(creditNoteGUID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsPayableApi.aPGETCreditNote: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccountsPayableApi();
$creditNoteGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AccountsPayableApi->new();
my $creditNoteGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->aPGETCreditNote(creditNoteGUID => $creditNoteGUID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountsPayableApi->aPGETCreditNote: $@\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.AccountsPayableApi()
creditNoteGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # AP_GET_CreditNote
    api_response = api_instance.a_pget_credit_note(creditNoteGUID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsPayableApi->aPGETCreditNote: %s\n" % e)
extern crate AccountsPayableApi;

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

    let mut context = AccountsPayableApi::Context::default();
    let result = client.aPGETCreditNote(creditNoteGUID, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
creditNoteGUID*
UUID (uuid)
Required

Responses


aPGETDraftBatch

AP_GET_DraftBatch

Get or create current AP draft batch.


/v3/ap/batches/draft

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,application/problem+json" \
 "https://api.dev.spenda.co/api/v3/ap/batches/draft"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountsPayableApi;

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

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

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

        try {
            Batch result = apiInstance.aPGETDraftBatch();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETDraftBatch");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.AccountsPayableApi;

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

        try {
            Batch result = apiInstance.aPGETDraftBatch();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETDraftBatch");
            e.printStackTrace();
        }
    }
}


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

// AP_GET_DraftBatch
[apiInstance aPGETDraftBatchWithCompletionHandler: 
              ^(Batch output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.AccountsPayableApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.aPGETDraftBatch(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                // AP_GET_DraftBatch
                Batch result = apiInstance.aPGETDraftBatch();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsPayableApi.aPGETDraftBatch: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # AP_GET_DraftBatch
    api_response = api_instance.a_pget_draft_batch()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsPayableApi->aPGETDraftBatch: %s\n" % e)
extern crate AccountsPayableApi;

pub fn main() {

    let mut context = AccountsPayableApi::Context::default();
    let result = client.aPGETDraftBatch(&context).wait();

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

Scopes

Parameters

Responses


aPGETPurchaseInvoice

AP_GET_PurchaseInvoice

Gets a single Purchase Invoice by identifier.


/v3/ap/purchaseInvoices/{purchaseInvoiceGUID}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,application/problem+json" \
 "https://api.dev.spenda.co/api/v3/ap/purchaseInvoices/{purchaseInvoiceGUID}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountsPayableApi;

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

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

        // Create an instance of the API class
        AccountsPayableApi apiInstance = new AccountsPayableApi();
        UUID purchaseInvoiceGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            PurchaseInvoice result = apiInstance.aPGETPurchaseInvoice(purchaseInvoiceGUID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETPurchaseInvoice");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID purchaseInvoiceGUID = new UUID(); // UUID | 

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

import org.openapitools.client.api.AccountsPayableApi;

public class AccountsPayableApiExample {
    public static void main(String[] args) {
        AccountsPayableApi apiInstance = new AccountsPayableApi();
        UUID purchaseInvoiceGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            PurchaseInvoice result = apiInstance.aPGETPurchaseInvoice(purchaseInvoiceGUID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETPurchaseInvoice");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
AccountsPayableApi *apiInstance = [[AccountsPayableApi alloc] init];
UUID *purchaseInvoiceGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// AP_GET_PurchaseInvoice
[apiInstance aPGETPurchaseInvoiceWith:purchaseInvoiceGUID
              completionHandler: ^(PurchaseInvoice output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.AccountsPayableApi()
var purchaseInvoiceGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.aPGETPurchaseInvoice(purchaseInvoiceGUID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AccountsPayableApi();
            var purchaseInvoiceGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // AP_GET_PurchaseInvoice
                PurchaseInvoice result = apiInstance.aPGETPurchaseInvoice(purchaseInvoiceGUID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsPayableApi.aPGETPurchaseInvoice: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccountsPayableApi();
$purchaseInvoiceGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AccountsPayableApi->new();
my $purchaseInvoiceGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->aPGETPurchaseInvoice(purchaseInvoiceGUID => $purchaseInvoiceGUID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountsPayableApi->aPGETPurchaseInvoice: $@\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.AccountsPayableApi()
purchaseInvoiceGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # AP_GET_PurchaseInvoice
    api_response = api_instance.a_pget_purchase_invoice(purchaseInvoiceGUID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsPayableApi->aPGETPurchaseInvoice: %s\n" % e)
extern crate AccountsPayableApi;

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

    let mut context = AccountsPayableApi::Context::default();
    let result = client.aPGETPurchaseInvoice(purchaseInvoiceGUID, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
purchaseInvoiceGUID*
UUID (uuid)
Required

Responses


aPGETSupplier

AP_GET_Supplier

Gets a single Supplier by identifier.


/v3/ap/suppliers/{supplierGUID}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,application/problem+json" \
 "https://api.dev.spenda.co/api/v3/ap/suppliers/{supplierGUID}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountsPayableApi;

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

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

        // Create an instance of the API class
        AccountsPayableApi apiInstance = new AccountsPayableApi();
        UUID supplierGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            Supplier result = apiInstance.aPGETSupplier(supplierGUID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETSupplier");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID supplierGUID = new UUID(); // UUID | 

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

import org.openapitools.client.api.AccountsPayableApi;

public class AccountsPayableApiExample {
    public static void main(String[] args) {
        AccountsPayableApi apiInstance = new AccountsPayableApi();
        UUID supplierGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            Supplier result = apiInstance.aPGETSupplier(supplierGUID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETSupplier");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
AccountsPayableApi *apiInstance = [[AccountsPayableApi alloc] init];
UUID *supplierGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// AP_GET_Supplier
[apiInstance aPGETSupplierWith:supplierGUID
              completionHandler: ^(Supplier output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.AccountsPayableApi()
var supplierGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.aPGETSupplier(supplierGUID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AccountsPayableApi();
            var supplierGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // AP_GET_Supplier
                Supplier result = apiInstance.aPGETSupplier(supplierGUID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsPayableApi.aPGETSupplier: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccountsPayableApi();
$supplierGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AccountsPayableApi->new();
my $supplierGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->aPGETSupplier(supplierGUID => $supplierGUID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountsPayableApi->aPGETSupplier: $@\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.AccountsPayableApi()
supplierGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # AP_GET_Supplier
    api_response = api_instance.a_pget_supplier(supplierGUID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsPayableApi->aPGETSupplier: %s\n" % e)
extern crate AccountsPayableApi;

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

    let mut context = AccountsPayableApi::Context::default();
    let result = client.aPGETSupplier(supplierGUID, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
supplierGUID*
UUID (uuid)
Required

Responses


aPGETSuppliers

AP_GET_Suppliers

Gets a list of all suppliers.


/v3/ap/suppliers

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,application/problem+json" \
 "https://api.dev.spenda.co/api/v3/ap/suppliers"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountsPayableApi;

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

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

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

        try {
            Suppliers result = apiInstance.aPGETSuppliers();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETSuppliers");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.AccountsPayableApi;

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

        try {
            Suppliers result = apiInstance.aPGETSuppliers();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETSuppliers");
            e.printStackTrace();
        }
    }
}


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

// AP_GET_Suppliers
[apiInstance aPGETSuppliersWithCompletionHandler: 
              ^(Suppliers output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.AccountsPayableApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.aPGETSuppliers(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                // AP_GET_Suppliers
                Suppliers result = apiInstance.aPGETSuppliers();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsPayableApi.aPGETSuppliers: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # AP_GET_Suppliers
    api_response = api_instance.a_pget_suppliers()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsPayableApi->aPGETSuppliers: %s\n" % e)
extern crate AccountsPayableApi;

pub fn main() {

    let mut context = AccountsPayableApi::Context::default();
    let result = client.aPGETSuppliers(&context).wait();

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

Scopes

Parameters

Responses


aPPUTBatch

AP_PUT_Batch

Update an existing Batch


/v3/ap/batches/{batchGuid}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json,application/problem+json" \
 -H "Content-Type: application/json" \
 "https://api.dev.spenda.co/api/v3/ap/batches/{batchGuid}" \
 -d '{
  "updateTransactionsRequest" : {
    "recordVersion" : "recordVersion",
    "batchTransactions" : [ {
      "amountApplied" : 0.8008281904610115,
      "guid" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "type" : "DebitNote"
    }, {
      "amountApplied" : 0.8008281904610115,
      "guid" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
      "type" : "DebitNote"
    } ]
  },
  "$type" : "transactions"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountsPayableApi;

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

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

        // Create an instance of the API class
        AccountsPayableApi apiInstance = new AccountsPayableApi();
        UUID batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UpdateBatch updateBatch = {"$type":"transactions","updateTransactionsRequest":{"recordVersion":"string","batchTransactions":[{"type":"DebitNote","guid":"string","amountApplied":0}]}}; // UpdateBatch | 

        try {
            UpdateBatchResponse result = apiInstance.aPPUTBatch(batchGuid, updateBatch);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPPUTBatch");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID batchGuid = new UUID(); // UUID | 
final UpdateBatch updateBatch = new UpdateBatch(); // UpdateBatch | 

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

import org.openapitools.client.api.AccountsPayableApi;

public class AccountsPayableApiExample {
    public static void main(String[] args) {
        AccountsPayableApi apiInstance = new AccountsPayableApi();
        UUID batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UpdateBatch updateBatch = {"$type":"transactions","updateTransactionsRequest":{"recordVersion":"string","batchTransactions":[{"type":"DebitNote","guid":"string","amountApplied":0}]}}; // UpdateBatch | 

        try {
            UpdateBatchResponse result = apiInstance.aPPUTBatch(batchGuid, updateBatch);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPPUTBatch");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
AccountsPayableApi *apiInstance = [[AccountsPayableApi alloc] init];
UUID *batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
UpdateBatch *updateBatch = {"$type":"transactions","updateTransactionsRequest":{"recordVersion":"string","batchTransactions":[{"type":"DebitNote","guid":"string","amountApplied":0}]}}; //  (optional)

// AP_PUT_Batch
[apiInstance aPPUTBatchWith:batchGuid
    updateBatch:updateBatch
              completionHandler: ^(UpdateBatchResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.AccountsPayableApi()
var batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var opts = {
  'updateBatch': {"$type":"transactions","updateTransactionsRequest":{"recordVersion":"string","batchTransactions":[{"type":"DebitNote","guid":"string","amountApplied":0}]}} // {UpdateBatch} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.aPPUTBatch(batchGuid, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AccountsPayableApi();
            var batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var updateBatch = new UpdateBatch(); // UpdateBatch |  (optional) 

            try {
                // AP_PUT_Batch
                UpdateBatchResponse result = apiInstance.aPPUTBatch(batchGuid, updateBatch);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsPayableApi.aPPUTBatch: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccountsPayableApi();
$batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$updateBatch = {"$type":"transactions","updateTransactionsRequest":{"recordVersion":"string","batchTransactions":[{"type":"DebitNote","guid":"string","amountApplied":0}]}}; // UpdateBatch | 

try {
    $result = $api_instance->aPPUTBatch($batchGuid, $updateBatch);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AccountsPayableApi->aPPUTBatch: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AccountsPayableApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AccountsPayableApi->new();
my $batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $updateBatch = WWW::OPenAPIClient::Object::UpdateBatch->new(); # UpdateBatch | 

eval {
    my $result = $api_instance->aPPUTBatch(batchGuid => $batchGuid, updateBatch => $updateBatch);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountsPayableApi->aPPUTBatch: $@\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.AccountsPayableApi()
batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
updateBatch = {"$type":"transactions","updateTransactionsRequest":{"recordVersion":"string","batchTransactions":[{"type":"DebitNote","guid":"string","amountApplied":0}]}} # UpdateBatch |  (optional)

try:
    # AP_PUT_Batch
    api_response = api_instance.a_pput_batch(batchGuid, updateBatch=updateBatch)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsPayableApi->aPPUTBatch: %s\n" % e)
extern crate AccountsPayableApi;

pub fn main() {
    let batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let updateBatch = {"$type":"transactions","updateTransactionsRequest":{"recordVersion":"string","batchTransactions":[{"type":"DebitNote","guid":"string","amountApplied":0}]}}; // UpdateBatch

    let mut context = AccountsPayableApi::Context::default();
    let result = client.aPPUTBatch(batchGuid, updateBatch, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
batchGuid*
UUID (uuid)
Required
Body parameters
Name Description
updateBatch

Responses


aPTestingPaymentBatchPUT

AP_Testing_PaymentBatch_PUT

Updates an existing Payment.


/v3/ap/testing/PaymentBatch

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json,application/problem+json" \
 -H "Content-Type: application/json" \
 "https://api.dev.spenda.co/api/v3/ap/testing/PaymentBatch" \
 -d '{
  "batchGuid" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "createdDate" : "2000-01-23T04:56:07.000+00:00",
  "dbStatus" : "dbStatus"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountsPayableApi;

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

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

        // Create an instance of the API class
        AccountsPayableApi apiInstance = new AccountsPayableApi();
        UpdatePaymentBatchRequest updatePaymentBatchRequest = {"batchGuid":"string","dbStatus":"string","createdDate":"string"}; // UpdatePaymentBatchRequest | 

        try {
            Object result = apiInstance.aPTestingPaymentBatchPUT(updatePaymentBatchRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPTestingPaymentBatchPUT");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UpdatePaymentBatchRequest updatePaymentBatchRequest = new UpdatePaymentBatchRequest(); // UpdatePaymentBatchRequest | 

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

import org.openapitools.client.api.AccountsPayableApi;

public class AccountsPayableApiExample {
    public static void main(String[] args) {
        AccountsPayableApi apiInstance = new AccountsPayableApi();
        UpdatePaymentBatchRequest updatePaymentBatchRequest = {"batchGuid":"string","dbStatus":"string","createdDate":"string"}; // UpdatePaymentBatchRequest | 

        try {
            Object result = apiInstance.aPTestingPaymentBatchPUT(updatePaymentBatchRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPTestingPaymentBatchPUT");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
AccountsPayableApi *apiInstance = [[AccountsPayableApi alloc] init];
UpdatePaymentBatchRequest *updatePaymentBatchRequest = {"batchGuid":"string","dbStatus":"string","createdDate":"string"}; //  (optional)

// AP_Testing_PaymentBatch_PUT
[apiInstance aPTestingPaymentBatchPUTWith:updatePaymentBatchRequest
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.AccountsPayableApi()
var opts = {
  'updatePaymentBatchRequest': {"batchGuid":"string","dbStatus":"string","createdDate":"string"} // {UpdatePaymentBatchRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.aPTestingPaymentBatchPUT(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AccountsPayableApi();
            var updatePaymentBatchRequest = new UpdatePaymentBatchRequest(); // UpdatePaymentBatchRequest |  (optional) 

            try {
                // AP_Testing_PaymentBatch_PUT
                Object result = apiInstance.aPTestingPaymentBatchPUT(updatePaymentBatchRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsPayableApi.aPTestingPaymentBatchPUT: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccountsPayableApi();
$updatePaymentBatchRequest = {"batchGuid":"string","dbStatus":"string","createdDate":"string"}; // UpdatePaymentBatchRequest | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AccountsPayableApi->new();
my $updatePaymentBatchRequest = WWW::OPenAPIClient::Object::UpdatePaymentBatchRequest->new(); # UpdatePaymentBatchRequest | 

eval {
    my $result = $api_instance->aPTestingPaymentBatchPUT(updatePaymentBatchRequest => $updatePaymentBatchRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountsPayableApi->aPTestingPaymentBatchPUT: $@\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.AccountsPayableApi()
updatePaymentBatchRequest = {"batchGuid":"string","dbStatus":"string","createdDate":"string"} # UpdatePaymentBatchRequest |  (optional)

try:
    # AP_Testing_PaymentBatch_PUT
    api_response = api_instance.a_p_testing_payment_batch_put(updatePaymentBatchRequest=updatePaymentBatchRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsPayableApi->aPTestingPaymentBatchPUT: %s\n" % e)
extern crate AccountsPayableApi;

pub fn main() {
    let updatePaymentBatchRequest = {"batchGuid":"string","dbStatus":"string","createdDate":"string"}; // UpdatePaymentBatchRequest

    let mut context = AccountsPayableApi::Context::default();
    let result = client.aPTestingPaymentBatchPUT(updatePaymentBatchRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
updatePaymentBatchRequest

Responses


aPTestingTransactionsPUT

AP_Testing_Transactions_PUT

Updates an existing transaction.


/v3/ap/testing/transaction

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json,application/problem+json" \
 -H "Content-Type: application/json" \
 "https://api.dev.spenda.co/api/v3/ap/testing/transaction" \
 -d '{
  "balance" : 0.8008281904610115,
  "transactionGuid" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "type" : "DebitNote",
  "status" : "status"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountsPayableApi;

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

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

        // Create an instance of the API class
        AccountsPayableApi apiInstance = new AccountsPayableApi();
        UpdateTransactionRequest updateTransactionRequest = {"type":"DebitNote","transactionGuid":"string","status":"string","balance":0}; // UpdateTransactionRequest | 

        try {
            Object result = apiInstance.aPTestingTransactionsPUT(updateTransactionRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPTestingTransactionsPUT");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UpdateTransactionRequest updateTransactionRequest = new UpdateTransactionRequest(); // UpdateTransactionRequest | 

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

import org.openapitools.client.api.AccountsPayableApi;

public class AccountsPayableApiExample {
    public static void main(String[] args) {
        AccountsPayableApi apiInstance = new AccountsPayableApi();
        UpdateTransactionRequest updateTransactionRequest = {"type":"DebitNote","transactionGuid":"string","status":"string","balance":0}; // UpdateTransactionRequest | 

        try {
            Object result = apiInstance.aPTestingTransactionsPUT(updateTransactionRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPTestingTransactionsPUT");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
AccountsPayableApi *apiInstance = [[AccountsPayableApi alloc] init];
UpdateTransactionRequest *updateTransactionRequest = {"type":"DebitNote","transactionGuid":"string","status":"string","balance":0}; //  (optional)

// AP_Testing_Transactions_PUT
[apiInstance aPTestingTransactionsPUTWith:updateTransactionRequest
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.AccountsPayableApi()
var opts = {
  'updateTransactionRequest': {"type":"DebitNote","transactionGuid":"string","status":"string","balance":0} // {UpdateTransactionRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.aPTestingTransactionsPUT(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AccountsPayableApi();
            var updateTransactionRequest = new UpdateTransactionRequest(); // UpdateTransactionRequest |  (optional) 

            try {
                // AP_Testing_Transactions_PUT
                Object result = apiInstance.aPTestingTransactionsPUT(updateTransactionRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsPayableApi.aPTestingTransactionsPUT: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccountsPayableApi();
$updateTransactionRequest = {"type":"DebitNote","transactionGuid":"string","status":"string","balance":0}; // UpdateTransactionRequest | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AccountsPayableApi->new();
my $updateTransactionRequest = WWW::OPenAPIClient::Object::UpdateTransactionRequest->new(); # UpdateTransactionRequest | 

eval {
    my $result = $api_instance->aPTestingTransactionsPUT(updateTransactionRequest => $updateTransactionRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountsPayableApi->aPTestingTransactionsPUT: $@\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.AccountsPayableApi()
updateTransactionRequest = {"type":"DebitNote","transactionGuid":"string","status":"string","balance":0} # UpdateTransactionRequest |  (optional)

try:
    # AP_Testing_Transactions_PUT
    api_response = api_instance.a_p_testing_transactions_put(updateTransactionRequest=updateTransactionRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsPayableApi->aPTestingTransactionsPUT: %s\n" % e)
extern crate AccountsPayableApi;

pub fn main() {
    let updateTransactionRequest = {"type":"DebitNote","transactionGuid":"string","status":"string","balance":0}; // UpdateTransactionRequest

    let mut context = AccountsPayableApi::Context::default();
    let result = client.aPTestingTransactionsPUT(updateTransactionRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
updateTransactionRequest

Responses


Adaptors

connectHubTestingGETAdaptor

ConnectHub_Testing_GET_Adaptor

Gets or creates a corresponding Synk'd Adaptor that will share finance system data with the ConnectHub connection.


/v3/connectHub/testing/adaptors

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,application/problem+json" \
 "https://api.dev.spenda.co/api/v3/connectHub/testing/adaptors"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdaptorsApi;

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

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

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

        try {
            Adaptor result = apiInstance.connectHubTestingGETAdaptor();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdaptorsApi#connectHubTestingGETAdaptor");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.AdaptorsApi;

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

        try {
            Adaptor result = apiInstance.connectHubTestingGETAdaptor();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdaptorsApi#connectHubTestingGETAdaptor");
            e.printStackTrace();
        }
    }
}


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

// ConnectHub_Testing_GET_Adaptor
[apiInstance connectHubTestingGETAdaptorWithCompletionHandler: 
              ^(Adaptor output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.AdaptorsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.connectHubTestingGETAdaptor(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                // ConnectHub_Testing_GET_Adaptor
                Adaptor result = apiInstance.connectHubTestingGETAdaptor();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdaptorsApi.connectHubTestingGETAdaptor: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # ConnectHub_Testing_GET_Adaptor
    api_response = api_instance.connect_hub_testing_get_adaptor()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdaptorsApi->connectHubTestingGETAdaptor: %s\n" % e)
extern crate AdaptorsApi;

pub fn main() {

    let mut context = AdaptorsApi::Context::default();
    let result = client.connectHubTestingGETAdaptor(&context).wait();

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

Scopes

Parameters

Responses


connectHubTestingGETAdaptorSyncLogs

ConnectHub_Testing_GET_Adaptor_SyncLogs

Gets the sync logs for the Synk'd Adaptor associated with the ConnectHub connection for the given data type.


/v3/connectHub/testing/adaptors/syncLogs

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,application/problem+json" \
 "https://api.dev.spenda.co/api/v3/connectHub/testing/adaptors/syncLogs?dataType="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AdaptorsApi;

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

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

        // Create an instance of the API class
        AdaptorsApi apiInstance = new AdaptorsApi();
        DataType dataType = ; // DataType | 

        try {
            array[SyncLog] result = apiInstance.connectHubTestingGETAdaptorSyncLogs(dataType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdaptorsApi#connectHubTestingGETAdaptorSyncLogs");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final DataType dataType = new DataType(); // DataType | 

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

import org.openapitools.client.api.AdaptorsApi;

public class AdaptorsApiExample {
    public static void main(String[] args) {
        AdaptorsApi apiInstance = new AdaptorsApi();
        DataType dataType = ; // DataType | 

        try {
            array[SyncLog] result = apiInstance.connectHubTestingGETAdaptorSyncLogs(dataType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdaptorsApi#connectHubTestingGETAdaptorSyncLogs");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
AdaptorsApi *apiInstance = [[AdaptorsApi alloc] init];
DataType *dataType = ; //  (default to null)

// ConnectHub_Testing_GET_Adaptor_SyncLogs
[apiInstance connectHubTestingGETAdaptorSyncLogsWith:dataType
              completionHandler: ^(array[SyncLog] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.AdaptorsApi()
var dataType = ; // {DataType} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.connectHubTestingGETAdaptorSyncLogs(dataType, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AdaptorsApi();
            var dataType = new DataType(); // DataType |  (default to null)

            try {
                // ConnectHub_Testing_GET_Adaptor_SyncLogs
                array[SyncLog] result = apiInstance.connectHubTestingGETAdaptorSyncLogs(dataType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdaptorsApi.connectHubTestingGETAdaptorSyncLogs: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdaptorsApi();
$dataType = ; // DataType | 

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

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

eval {
    my $result = $api_instance->connectHubTestingGETAdaptorSyncLogs(dataType => $dataType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdaptorsApi->connectHubTestingGETAdaptorSyncLogs: $@\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.AdaptorsApi()
dataType =  # DataType |  (default to null)

try:
    # ConnectHub_Testing_GET_Adaptor_SyncLogs
    api_response = api_instance.connect_hub_testing_get_adaptor_sync_logs(dataType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdaptorsApi->connectHubTestingGETAdaptorSyncLogs: %s\n" % e)
extern crate AdaptorsApi;

pub fn main() {
    let dataType = ; // DataType

    let mut context = AdaptorsApi::Context::default();
    let result = client.connectHubTestingGETAdaptorSyncLogs(dataType, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
dataType*
DataType
Required

Responses


ConnectHub

connectHubDELETEConnection

ConnectHub_DELETE_Connection

Deletes the active finance system connection.


/v3/connectHub/connection

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json,application/problem+json" \
 "https://api.dev.spenda.co/api/v3/connectHub/connection"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ConnectHubApi;

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

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

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

        try {
            Object result = apiInstance.connectHubDELETEConnection();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubDELETEConnection");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.ConnectHubApi;

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

        try {
            Object result = apiInstance.connectHubDELETEConnection();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubDELETEConnection");
            e.printStackTrace();
        }
    }
}


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

// ConnectHub_DELETE_Connection
[apiInstance connectHubDELETEConnectionWithCompletionHandler: 
              ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.ConnectHubApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.connectHubDELETEConnection(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                // ConnectHub_DELETE_Connection
                Object result = apiInstance.connectHubDELETEConnection();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectHubApi.connectHubDELETEConnection: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # ConnectHub_DELETE_Connection
    api_response = api_instance.connect_hub_delete_connection()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectHubApi->connectHubDELETEConnection: %s\n" % e)
extern crate ConnectHubApi;

pub fn main() {

    let mut context = ConnectHubApi::Context::default();
    let result = client.connectHubDELETEConnection(&context).wait();

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

Scopes

Parameters

Responses


connectHubGETBatch

ConnectHub_GET_Batch

Returns a single connection batch.


/v3/connectHub/batches/{connectionBatchGUID}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,application/problem+json" \
 "https://api.dev.spenda.co/api/v3/connectHub/batches/{connectionBatchGUID}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ConnectHubApi;

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

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

        // Create an instance of the API class
        ConnectHubApi apiInstance = new ConnectHubApi();
        UUID connectionBatchGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            ConnectionBatchResponse result = apiInstance.connectHubGETBatch(connectionBatchGUID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubGETBatch");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID connectionBatchGUID = new UUID(); // UUID | 

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

import org.openapitools.client.api.ConnectHubApi;

public class ConnectHubApiExample {
    public static void main(String[] args) {
        ConnectHubApi apiInstance = new ConnectHubApi();
        UUID connectionBatchGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            ConnectionBatchResponse result = apiInstance.connectHubGETBatch(connectionBatchGUID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubGETBatch");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ConnectHubApi *apiInstance = [[ConnectHubApi alloc] init];
UUID *connectionBatchGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// ConnectHub_GET_Batch
[apiInstance connectHubGETBatchWith:connectionBatchGUID
              completionHandler: ^(ConnectionBatchResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.ConnectHubApi()
var connectionBatchGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.connectHubGETBatch(connectionBatchGUID, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new ConnectHubApi();
            var connectionBatchGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // ConnectHub_GET_Batch
                ConnectionBatchResponse result = apiInstance.connectHubGETBatch(connectionBatchGUID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectHubApi.connectHubGETBatch: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ConnectHubApi();
$connectionBatchGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ConnectHubApi->new();
my $connectionBatchGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->connectHubGETBatch(connectionBatchGUID => $connectionBatchGUID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ConnectHubApi->connectHubGETBatch: $@\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.ConnectHubApi()
connectionBatchGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # ConnectHub_GET_Batch
    api_response = api_instance.connect_hub_get_batch(connectionBatchGUID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectHubApi->connectHubGETBatch: %s\n" % e)
extern crate ConnectHubApi;

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

    let mut context = ConnectHubApi::Context::default();
    let result = client.connectHubGETBatch(connectionBatchGUID, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
connectionBatchGUID*
UUID (uuid)
Required

Responses


connectHubGETBatches

ConnectHub_GET_Batches

Queries for data import or export batches for your finance system connection.


/v3/connectHub/batches

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,application/problem+json" \
 "https://api.dev.spenda.co/api/v3/connectHub/batches?startDateFrom=2013-10-20&startDateTo=2013-10-20&statuses=&directions=&dataTypes="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ConnectHubApi;

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

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

        // Create an instance of the API class
        ConnectHubApi apiInstance = new ConnectHubApi();
        date startDateFrom = 2013-10-20; // date | 
        date startDateTo = 2013-10-20; // date | 
        array[ConnectionBatchStatus] statuses = ; // array[ConnectionBatchStatus] | 
        array[BatchDirection] directions = ; // array[BatchDirection] | 
        array[DataType] dataTypes = ; // array[DataType] | 

        try {
            ConnectionBatches result = apiInstance.connectHubGETBatches(startDateFrom, startDateTo, statuses, directions, dataTypes);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubGETBatches");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final date startDateFrom = new date(); // date | 
final date startDateTo = new date(); // date | 
final array[ConnectionBatchStatus] statuses = new array[ConnectionBatchStatus](); // array[ConnectionBatchStatus] | 
final array[BatchDirection] directions = new array[BatchDirection](); // array[BatchDirection] | 
final array[DataType] dataTypes = new array[DataType](); // array[DataType] | 

try {
    final result = await api_instance.connectHubGETBatches(startDateFrom, startDateTo, statuses, directions, dataTypes);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->connectHubGETBatches: $e\n');
}

import org.openapitools.client.api.ConnectHubApi;

public class ConnectHubApiExample {
    public static void main(String[] args) {
        ConnectHubApi apiInstance = new ConnectHubApi();
        date startDateFrom = 2013-10-20; // date | 
        date startDateTo = 2013-10-20; // date | 
        array[ConnectionBatchStatus] statuses = ; // array[ConnectionBatchStatus] | 
        array[BatchDirection] directions = ; // array[BatchDirection] | 
        array[DataType] dataTypes = ; // array[DataType] | 

        try {
            ConnectionBatches result = apiInstance.connectHubGETBatches(startDateFrom, startDateTo, statuses, directions, dataTypes);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubGETBatches");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ConnectHubApi *apiInstance = [[ConnectHubApi alloc] init];
date *startDateFrom = 2013-10-20; //  (optional) (default to null)
date *startDateTo = 2013-10-20; //  (optional) (default to null)
array[ConnectionBatchStatus] *statuses = ; //  (optional) (default to null)
array[BatchDirection] *directions = ; //  (optional) (default to null)
array[DataType] *dataTypes = ; //  (optional) (default to null)

// ConnectHub_GET_Batches
[apiInstance connectHubGETBatchesWith:startDateFrom
    startDateTo:startDateTo
    statuses:statuses
    directions:directions
    dataTypes:dataTypes
              completionHandler: ^(ConnectionBatches output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.ConnectHubApi()
var opts = {
  'startDateFrom': 2013-10-20, // {date} 
  'startDateTo': 2013-10-20, // {date} 
  'statuses': , // {array[ConnectionBatchStatus]} 
  'directions': , // {array[BatchDirection]} 
  'dataTypes':  // {array[DataType]} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.connectHubGETBatches(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new ConnectHubApi();
            var startDateFrom = 2013-10-20;  // date |  (optional)  (default to null)
            var startDateTo = 2013-10-20;  // date |  (optional)  (default to null)
            var statuses = new array[ConnectionBatchStatus](); // array[ConnectionBatchStatus] |  (optional)  (default to null)
            var directions = new array[BatchDirection](); // array[BatchDirection] |  (optional)  (default to null)
            var dataTypes = new array[DataType](); // array[DataType] |  (optional)  (default to null)

            try {
                // ConnectHub_GET_Batches
                ConnectionBatches result = apiInstance.connectHubGETBatches(startDateFrom, startDateTo, statuses, directions, dataTypes);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectHubApi.connectHubGETBatches: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ConnectHubApi();
$startDateFrom = 2013-10-20; // date | 
$startDateTo = 2013-10-20; // date | 
$statuses = ; // array[ConnectionBatchStatus] | 
$directions = ; // array[BatchDirection] | 
$dataTypes = ; // array[DataType] | 

try {
    $result = $api_instance->connectHubGETBatches($startDateFrom, $startDateTo, $statuses, $directions, $dataTypes);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ConnectHubApi->connectHubGETBatches: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ConnectHubApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ConnectHubApi->new();
my $startDateFrom = 2013-10-20; # date | 
my $startDateTo = 2013-10-20; # date | 
my $statuses = []; # array[ConnectionBatchStatus] | 
my $directions = []; # array[BatchDirection] | 
my $dataTypes = []; # array[DataType] | 

eval {
    my $result = $api_instance->connectHubGETBatches(startDateFrom => $startDateFrom, startDateTo => $startDateTo, statuses => $statuses, directions => $directions, dataTypes => $dataTypes);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ConnectHubApi->connectHubGETBatches: $@\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.ConnectHubApi()
startDateFrom = 2013-10-20 # date |  (optional) (default to null)
startDateTo = 2013-10-20 # date |  (optional) (default to null)
statuses =  # array[ConnectionBatchStatus] |  (optional) (default to null)
directions =  # array[BatchDirection] |  (optional) (default to null)
dataTypes =  # array[DataType] |  (optional) (default to null)

try:
    # ConnectHub_GET_Batches
    api_response = api_instance.connect_hub_get_batches(startDateFrom=startDateFrom, startDateTo=startDateTo, statuses=statuses, directions=directions, dataTypes=dataTypes)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectHubApi->connectHubGETBatches: %s\n" % e)
extern crate ConnectHubApi;

pub fn main() {
    let startDateFrom = 2013-10-20; // date
    let startDateTo = 2013-10-20; // date
    let statuses = ; // array[ConnectionBatchStatus]
    let directions = ; // array[BatchDirection]
    let dataTypes = ; // array[DataType]

    let mut context = ConnectHubApi::Context::default();
    let result = client.connectHubGETBatches(startDateFrom, startDateTo, statuses, directions, dataTypes, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
startDateFrom
date (date)
startDateTo
date (date)
statuses
array[ConnectionBatchStatus]
directions
array[BatchDirection]
dataTypes
array[DataType]

Responses


connectHubGETConnection

ConnectHub_GET_Connection

Gets the active finance system connection.


/v3/connectHub/connection

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,application/problem+json" \
 "https://api.dev.spenda.co/api/v3/connectHub/connection"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ConnectHubApi;

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

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

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

        try {
            ConnectionResponse result = apiInstance.connectHubGETConnection();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubGETConnection");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.ConnectHubApi;

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

        try {
            ConnectionResponse result = apiInstance.connectHubGETConnection();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubGETConnection");
            e.printStackTrace();
        }
    }
}


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

// ConnectHub_GET_Connection
[apiInstance connectHubGETConnectionWithCompletionHandler: 
              ^(ConnectionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.ConnectHubApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.connectHubGETConnection(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                // ConnectHub_GET_Connection
                ConnectionResponse result = apiInstance.connectHubGETConnection();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectHubApi.connectHubGETConnection: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # ConnectHub_GET_Connection
    api_response = api_instance.connect_hub_get_connection()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectHubApi->connectHubGETConnection: %s\n" % e)
extern crate ConnectHubApi;

pub fn main() {

    let mut context = ConnectHubApi::Context::default();
    let result = client.connectHubGETConnection(&context).wait();

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

Scopes

Parameters

Responses


connectHubGETConnectionTypes

ConnectHub_GET_ConnectionTypes

Gets the types of finance systems available for connecting to.


/v3/connectHub/connectionTypes

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,application/problem+json" \
 "https://api.dev.spenda.co/api/v3/connectHub/connectionTypes"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ConnectHubApi;

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

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

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

        try {
            GetConnectionTypesResponse result = apiInstance.connectHubGETConnectionTypes();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubGETConnectionTypes");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.ConnectHubApi;

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

        try {
            GetConnectionTypesResponse result = apiInstance.connectHubGETConnectionTypes();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubGETConnectionTypes");
            e.printStackTrace();
        }
    }
}


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

// ConnectHub_GET_ConnectionTypes
[apiInstance connectHubGETConnectionTypesWithCompletionHandler: 
              ^(GetConnectionTypesResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.ConnectHubApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.connectHubGETConnectionTypes(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                // ConnectHub_GET_ConnectionTypes
                GetConnectionTypesResponse result = apiInstance.connectHubGETConnectionTypes();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectHubApi.connectHubGETConnectionTypes: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # ConnectHub_GET_ConnectionTypes
    api_response = api_instance.connect_hub_get_connection_types()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectHubApi->connectHubGETConnectionTypes: %s\n" % e)
extern crate ConnectHubApi;

pub fn main() {

    let mut context = ConnectHubApi::Context::default();
    let result = client.connectHubGETConnectionTypes(&context).wait();

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

Scopes

Parameters

Responses


connectHubPATCHConnection

ConnectHub_PATCH_Connection

Manages the active finance system connection.


/v3/connectHub/connection

Usage and SDK Samples

curl -X PATCH \
 -H "Accept: application/json,application/problem+json" \
 -H "Content-Type: application/json" \
 "https://api.dev.spenda.co/api/v3/connectHub/connection" \
 -d '{
  "connectRequest" : {
    "oAuthCallbackUri" : "https://openapi-generator.tech",
    "state" : "state"
  },
  "$type" : "connect"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ConnectHubApi;

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

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

        // Create an instance of the API class
        ConnectHubApi apiInstance = new ConnectHubApi();
        UpdateConnection updateConnection = {"$type":"connect","connectRequest":{"oAuthCallbackUri":"string","state":"string"}}; // UpdateConnection | 

        try {
            UpdateConnectionResponse result = apiInstance.connectHubPATCHConnection(updateConnection);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubPATCHConnection");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UpdateConnection updateConnection = new UpdateConnection(); // UpdateConnection | 

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

import org.openapitools.client.api.ConnectHubApi;

public class ConnectHubApiExample {
    public static void main(String[] args) {
        ConnectHubApi apiInstance = new ConnectHubApi();
        UpdateConnection updateConnection = {"$type":"connect","connectRequest":{"oAuthCallbackUri":"string","state":"string"}}; // UpdateConnection | 

        try {
            UpdateConnectionResponse result = apiInstance.connectHubPATCHConnection(updateConnection);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubPATCHConnection");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ConnectHubApi *apiInstance = [[ConnectHubApi alloc] init];
UpdateConnection *updateConnection = {"$type":"connect","connectRequest":{"oAuthCallbackUri":"string","state":"string"}}; //  (optional)

// ConnectHub_PATCH_Connection
[apiInstance connectHubPATCHConnectionWith:updateConnection
              completionHandler: ^(UpdateConnectionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.ConnectHubApi()
var opts = {
  'updateConnection': {"$type":"connect","connectRequest":{"oAuthCallbackUri":"string","state":"string"}} // {UpdateConnection} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.connectHubPATCHConnection(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new ConnectHubApi();
            var updateConnection = new UpdateConnection(); // UpdateConnection |  (optional) 

            try {
                // ConnectHub_PATCH_Connection
                UpdateConnectionResponse result = apiInstance.connectHubPATCHConnection(updateConnection);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectHubApi.connectHubPATCHConnection: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ConnectHubApi();
$updateConnection = {"$type":"connect","connectRequest":{"oAuthCallbackUri":"string","state":"string"}}; // UpdateConnection | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ConnectHubApi->new();
my $updateConnection = WWW::OPenAPIClient::Object::UpdateConnection->new(); # UpdateConnection | 

eval {
    my $result = $api_instance->connectHubPATCHConnection(updateConnection => $updateConnection);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ConnectHubApi->connectHubPATCHConnection: $@\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.ConnectHubApi()
updateConnection = {"$type":"connect","connectRequest":{"oAuthCallbackUri":"string","state":"string"}} # UpdateConnection |  (optional)

try:
    # ConnectHub_PATCH_Connection
    api_response = api_instance.connect_hub_patch_connection(updateConnection=updateConnection)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectHubApi->connectHubPATCHConnection: %s\n" % e)
extern crate ConnectHubApi;

pub fn main() {
    let updateConnection = {"$type":"connect","connectRequest":{"oAuthCallbackUri":"string","state":"string"}}; // UpdateConnection

    let mut context = ConnectHubApi::Context::default();
    let result = client.connectHubPATCHConnection(updateConnection, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
updateConnection

Responses


connectHubPOSTConnection

ConnectHub_POST_Connection

Creates a new finance system connection.


/v3/connectHub/connection

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json,application/problem+json" \
 -H "Content-Type: application/json" \
 "https://api.dev.spenda.co/api/v3/connectHub/connection" \
 -d '{
  "connectionType" : "Xero"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ConnectHubApi;

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

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

        // Create an instance of the API class
        ConnectHubApi apiInstance = new ConnectHubApi();
        CreateConnection createConnection = {"connectionType":"Xero"}; // CreateConnection | 

        try {
            ConnectionResponse result = apiInstance.connectHubPOSTConnection(createConnection);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubPOSTConnection");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreateConnection createConnection = new CreateConnection(); // CreateConnection | 

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

import org.openapitools.client.api.ConnectHubApi;

public class ConnectHubApiExample {
    public static void main(String[] args) {
        ConnectHubApi apiInstance = new ConnectHubApi();
        CreateConnection createConnection = {"connectionType":"Xero"}; // CreateConnection | 

        try {
            ConnectionResponse result = apiInstance.connectHubPOSTConnection(createConnection);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubPOSTConnection");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ConnectHubApi *apiInstance = [[ConnectHubApi alloc] init];
CreateConnection *createConnection = {"connectionType":"Xero"}; //  (optional)

// ConnectHub_POST_Connection
[apiInstance connectHubPOSTConnectionWith:createConnection
              completionHandler: ^(ConnectionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.ConnectHubApi()
var opts = {
  'createConnection': {"connectionType":"Xero"} // {CreateConnection} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.connectHubPOSTConnection(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new ConnectHubApi();
            var createConnection = new CreateConnection(); // CreateConnection |  (optional) 

            try {
                // ConnectHub_POST_Connection
                ConnectionResponse result = apiInstance.connectHubPOSTConnection(createConnection);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectHubApi.connectHubPOSTConnection: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ConnectHubApi();
$createConnection = {"connectionType":"Xero"}; // CreateConnection | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ConnectHubApi->new();
my $createConnection = WWW::OPenAPIClient::Object::CreateConnection->new(); # CreateConnection | 

eval {
    my $result = $api_instance->connectHubPOSTConnection(createConnection => $createConnection);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ConnectHubApi->connectHubPOSTConnection: $@\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.ConnectHubApi()
createConnection = {"connectionType":"Xero"} # CreateConnection |  (optional)

try:
    # ConnectHub_POST_Connection
    api_response = api_instance.connect_hub_post_connection(createConnection=createConnection)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectHubApi->connectHubPOSTConnection: %s\n" % e)
extern crate ConnectHubApi;

pub fn main() {
    let createConnection = {"connectionType":"Xero"}; // CreateConnection

    let mut context = ConnectHubApi::Context::default();
    let result = client.connectHubPOSTConnection(createConnection, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
createConnection

Responses


connectHubTestingDELETEData

ConnectHub_Testing_DELETE_Data

When the Connection is in Test Operating Mode, deletes objects used when simulating an import from the finance system.


/v3/connectHub/testing

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json,application/problem+json" \
 "https://api.dev.spenda.co/api/v3/connectHub/testing?dataType="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ConnectHubApi;

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

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

        // Create an instance of the API class
        ConnectHubApi apiInstance = new ConnectHubApi();
        ImportDataType dataType = ; // ImportDataType | 

        try {
            Object result = apiInstance.connectHubTestingDELETEData(dataType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubTestingDELETEData");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ImportDataType dataType = new ImportDataType(); // ImportDataType | 

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

import org.openapitools.client.api.ConnectHubApi;

public class ConnectHubApiExample {
    public static void main(String[] args) {
        ConnectHubApi apiInstance = new ConnectHubApi();
        ImportDataType dataType = ; // ImportDataType | 

        try {
            Object result = apiInstance.connectHubTestingDELETEData(dataType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubTestingDELETEData");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ConnectHubApi *apiInstance = [[ConnectHubApi alloc] init];
ImportDataType *dataType = ; //  (default to null)

// ConnectHub_Testing_DELETE_Data
[apiInstance connectHubTestingDELETEDataWith:dataType
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.ConnectHubApi()
var dataType = ; // {ImportDataType} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.connectHubTestingDELETEData(dataType, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new ConnectHubApi();
            var dataType = new ImportDataType(); // ImportDataType |  (default to null)

            try {
                // ConnectHub_Testing_DELETE_Data
                Object result = apiInstance.connectHubTestingDELETEData(dataType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectHubApi.connectHubTestingDELETEData: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ConnectHubApi();
$dataType = ; // ImportDataType | 

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

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

eval {
    my $result = $api_instance->connectHubTestingDELETEData(dataType => $dataType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ConnectHubApi->connectHubTestingDELETEData: $@\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.ConnectHubApi()
dataType =  # ImportDataType |  (default to null)

try:
    # ConnectHub_Testing_DELETE_Data
    api_response = api_instance.connect_hub_testing_delete_data(dataType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectHubApi->connectHubTestingDELETEData: %s\n" % e)
extern crate ConnectHubApi;

pub fn main() {
    let dataType = ; // ImportDataType

    let mut context = ConnectHubApi::Context::default();
    let result = client.connectHubTestingDELETEData(dataType, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
dataType*
ImportDataType
Required

Responses


connectHubTestingGETAdaptor

ConnectHub_Testing_GET_Adaptor

Gets or creates a corresponding Synk'd Adaptor that will share finance system data with the ConnectHub connection.


/v3/connectHub/testing/adaptors

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,application/problem+json" \
 "https://api.dev.spenda.co/api/v3/connectHub/testing/adaptors"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ConnectHubApi;

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

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

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

        try {
            Adaptor result = apiInstance.connectHubTestingGETAdaptor();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubTestingGETAdaptor");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.ConnectHubApi;

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

        try {
            Adaptor result = apiInstance.connectHubTestingGETAdaptor();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubTestingGETAdaptor");
            e.printStackTrace();
        }
    }
}


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

// ConnectHub_Testing_GET_Adaptor
[apiInstance connectHubTestingGETAdaptorWithCompletionHandler: 
              ^(Adaptor output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.ConnectHubApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.connectHubTestingGETAdaptor(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                // ConnectHub_Testing_GET_Adaptor
                Adaptor result = apiInstance.connectHubTestingGETAdaptor();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectHubApi.connectHubTestingGETAdaptor: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # ConnectHub_Testing_GET_Adaptor
    api_response = api_instance.connect_hub_testing_get_adaptor()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectHubApi->connectHubTestingGETAdaptor: %s\n" % e)
extern crate ConnectHubApi;

pub fn main() {

    let mut context = ConnectHubApi::Context::default();
    let result = client.connectHubTestingGETAdaptor(&context).wait();

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

Scopes

Parameters

Responses


connectHubTestingGETAdaptorSyncLogs

ConnectHub_Testing_GET_Adaptor_SyncLogs

Gets the sync logs for the Synk'd Adaptor associated with the ConnectHub connection for the given data type.


/v3/connectHub/testing/adaptors/syncLogs

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,application/problem+json" \
 "https://api.dev.spenda.co/api/v3/connectHub/testing/adaptors/syncLogs?dataType="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ConnectHubApi;

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

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

        // Create an instance of the API class
        ConnectHubApi apiInstance = new ConnectHubApi();
        DataType dataType = ; // DataType | 

        try {
            array[SyncLog] result = apiInstance.connectHubTestingGETAdaptorSyncLogs(dataType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubTestingGETAdaptorSyncLogs");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final DataType dataType = new DataType(); // DataType | 

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

import org.openapitools.client.api.ConnectHubApi;

public class ConnectHubApiExample {
    public static void main(String[] args) {
        ConnectHubApi apiInstance = new ConnectHubApi();
        DataType dataType = ; // DataType | 

        try {
            array[SyncLog] result = apiInstance.connectHubTestingGETAdaptorSyncLogs(dataType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubTestingGETAdaptorSyncLogs");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ConnectHubApi *apiInstance = [[ConnectHubApi alloc] init];
DataType *dataType = ; //  (default to null)

// ConnectHub_Testing_GET_Adaptor_SyncLogs
[apiInstance connectHubTestingGETAdaptorSyncLogsWith:dataType
              completionHandler: ^(array[SyncLog] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.ConnectHubApi()
var dataType = ; // {DataType} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.connectHubTestingGETAdaptorSyncLogs(dataType, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new ConnectHubApi();
            var dataType = new DataType(); // DataType |  (default to null)

            try {
                // ConnectHub_Testing_GET_Adaptor_SyncLogs
                array[SyncLog] result = apiInstance.connectHubTestingGETAdaptorSyncLogs(dataType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectHubApi.connectHubTestingGETAdaptorSyncLogs: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ConnectHubApi();
$dataType = ; // DataType | 

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

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

eval {
    my $result = $api_instance->connectHubTestingGETAdaptorSyncLogs(dataType => $dataType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ConnectHubApi->connectHubTestingGETAdaptorSyncLogs: $@\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.ConnectHubApi()
dataType =  # DataType |  (default to null)

try:
    # ConnectHub_Testing_GET_Adaptor_SyncLogs
    api_response = api_instance.connect_hub_testing_get_adaptor_sync_logs(dataType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectHubApi->connectHubTestingGETAdaptorSyncLogs: %s\n" % e)
extern crate ConnectHubApi;

pub fn main() {
    let dataType = ; // DataType

    let mut context = ConnectHubApi::Context::default();
    let result = client.connectHubTestingGETAdaptorSyncLogs(dataType, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
dataType*
DataType
Required

Responses


connectHubTestingPATCHConnection

ConnectHub_Testing_PATCH_Connection

When the operating mode is "Test", all interaction with the finance system will be simulated.


/v3/connectHub/testing

Usage and SDK Samples

curl -X PATCH \
 -H "Accept: application/json,application/problem+json" \
 -H "Content-Type: application/json" \
 "https://api.dev.spenda.co/api/v3/connectHub/testing" \
 -d '{
  "setOperatingModeRequest" : {
    "operatingMode" : "Normal"
  },
  "$type" : "setOperatingMode"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ConnectHubApi;

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

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

        // Create an instance of the API class
        ConnectHubApi apiInstance = new ConnectHubApi();
        TestUpdateConnection testUpdateConnection = {"$type":"setOperatingMode","setOperatingModeRequest":{"operatingMode":"Normal"}}; // TestUpdateConnection | 

        try {
            TestUpdateConnectionResponse result = apiInstance.connectHubTestingPATCHConnection(testUpdateConnection);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubTestingPATCHConnection");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final TestUpdateConnection testUpdateConnection = new TestUpdateConnection(); // TestUpdateConnection | 

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

import org.openapitools.client.api.ConnectHubApi;

public class ConnectHubApiExample {
    public static void main(String[] args) {
        ConnectHubApi apiInstance = new ConnectHubApi();
        TestUpdateConnection testUpdateConnection = {"$type":"setOperatingMode","setOperatingModeRequest":{"operatingMode":"Normal"}}; // TestUpdateConnection | 

        try {
            TestUpdateConnectionResponse result = apiInstance.connectHubTestingPATCHConnection(testUpdateConnection);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubTestingPATCHConnection");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ConnectHubApi *apiInstance = [[ConnectHubApi alloc] init];
TestUpdateConnection *testUpdateConnection = {"$type":"setOperatingMode","setOperatingModeRequest":{"operatingMode":"Normal"}}; //  (optional)

// ConnectHub_Testing_PATCH_Connection
[apiInstance connectHubTestingPATCHConnectionWith:testUpdateConnection
              completionHandler: ^(TestUpdateConnectionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.ConnectHubApi()
var opts = {
  'testUpdateConnection': {"$type":"setOperatingMode","setOperatingModeRequest":{"operatingMode":"Normal"}} // {TestUpdateConnection} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.connectHubTestingPATCHConnection(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new ConnectHubApi();
            var testUpdateConnection = new TestUpdateConnection(); // TestUpdateConnection |  (optional) 

            try {
                // ConnectHub_Testing_PATCH_Connection
                TestUpdateConnectionResponse result = apiInstance.connectHubTestingPATCHConnection(testUpdateConnection);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectHubApi.connectHubTestingPATCHConnection: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ConnectHubApi();
$testUpdateConnection = {"$type":"setOperatingMode","setOperatingModeRequest":{"operatingMode":"Normal"}}; // TestUpdateConnection | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ConnectHubApi->new();
my $testUpdateConnection = WWW::OPenAPIClient::Object::TestUpdateConnection->new(); # TestUpdateConnection | 

eval {
    my $result = $api_instance->connectHubTestingPATCHConnection(testUpdateConnection => $testUpdateConnection);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ConnectHubApi->connectHubTestingPATCHConnection: $@\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.ConnectHubApi()
testUpdateConnection = {"$type":"setOperatingMode","setOperatingModeRequest":{"operatingMode":"Normal"}} # TestUpdateConnection |  (optional)

try:
    # ConnectHub_Testing_PATCH_Connection
    api_response = api_instance.connect_hub_testing_patch_connection(testUpdateConnection=testUpdateConnection)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectHubApi->connectHubTestingPATCHConnection: %s\n" % e)
extern crate ConnectHubApi;

pub fn main() {
    let testUpdateConnection = {"$type":"setOperatingMode","setOperatingModeRequest":{"operatingMode":"Normal"}}; // TestUpdateConnection

    let mut context = ConnectHubApi::Context::default();
    let result = client.connectHubTestingPATCHConnection(testUpdateConnection, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
testUpdateConnection

Responses


connectHubTestingPOSTData

ConnectHub_Testing_POST_Data

When the Connection is in Test Operating Mode, writes a collection of objects to be used when simulating an import from the finance system.


/v3/connectHub/testing

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json,application/problem+json" \
 -H "Content-Type: application/json" \
 "https://api.dev.spenda.co/api/v3/connectHub/testing" \
 -d '{
  "dataType" : "Supplier",
  "jsonValues" : [ "jsonValues", "jsonValues" ]
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ConnectHubApi;

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

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

        // Create an instance of the API class
        ConnectHubApi apiInstance = new ConnectHubApi();
        WriteTestDataRequest writeTestDataRequest = {"dataType":"Supplier","jsonValues":["string"]}; // WriteTestDataRequest | 

        try {
            Object result = apiInstance.connectHubTestingPOSTData(writeTestDataRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubTestingPOSTData");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final WriteTestDataRequest writeTestDataRequest = new WriteTestDataRequest(); // WriteTestDataRequest | 

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

import org.openapitools.client.api.ConnectHubApi;

public class ConnectHubApiExample {
    public static void main(String[] args) {
        ConnectHubApi apiInstance = new ConnectHubApi();
        WriteTestDataRequest writeTestDataRequest = {"dataType":"Supplier","jsonValues":["string"]}; // WriteTestDataRequest | 

        try {
            Object result = apiInstance.connectHubTestingPOSTData(writeTestDataRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubTestingPOSTData");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ConnectHubApi *apiInstance = [[ConnectHubApi alloc] init];
WriteTestDataRequest *writeTestDataRequest = {"dataType":"Supplier","jsonValues":["string"]}; //  (optional)

// ConnectHub_Testing_POST_Data
[apiInstance connectHubTestingPOSTDataWith:writeTestDataRequest
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.ConnectHubApi()
var opts = {
  'writeTestDataRequest': {"dataType":"Supplier","jsonValues":["string"]} // {WriteTestDataRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.connectHubTestingPOSTData(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new ConnectHubApi();
            var writeTestDataRequest = new WriteTestDataRequest(); // WriteTestDataRequest |  (optional) 

            try {
                // ConnectHub_Testing_POST_Data
                Object result = apiInstance.connectHubTestingPOSTData(writeTestDataRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectHubApi.connectHubTestingPOSTData: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ConnectHubApi();
$writeTestDataRequest = {"dataType":"Supplier","jsonValues":["string"]}; // WriteTestDataRequest | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ConnectHubApi->new();
my $writeTestDataRequest = WWW::OPenAPIClient::Object::WriteTestDataRequest->new(); # WriteTestDataRequest | 

eval {
    my $result = $api_instance->connectHubTestingPOSTData(writeTestDataRequest => $writeTestDataRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ConnectHubApi->connectHubTestingPOSTData: $@\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.ConnectHubApi()
writeTestDataRequest = {"dataType":"Supplier","jsonValues":["string"]} # WriteTestDataRequest |  (optional)

try:
    # ConnectHub_Testing_POST_Data
    api_response = api_instance.connect_hub_testing_post_data(writeTestDataRequest=writeTestDataRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectHubApi->connectHubTestingPOSTData: %s\n" % e)
extern crate ConnectHubApi;

pub fn main() {
    let writeTestDataRequest = {"dataType":"Supplier","jsonValues":["string"]}; // WriteTestDataRequest

    let mut context = ConnectHubApi::Context::default();
    let result = client.connectHubTestingPOSTData(writeTestDataRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
writeTestDataRequest

Responses


PaymentServices

paymentServicesTestingAccountsGETVerificationCode

PaymentServices_Testing_Accounts_GET_VerificationCode

Retrieves the verification code for a payment account.


/v3/paymentServices/testing/accounts/{paymentAccountGuid}/verificationCode

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,application/problem+json" \
 "https://api.dev.spenda.co/api/v3/paymentServices/testing/accounts/{paymentAccountGuid}/verificationCode"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PaymentServicesApi;

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

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

        // Create an instance of the API class
        PaymentServicesApi apiInstance = new PaymentServicesApi();
        UUID paymentAccountGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            GetAccountVerificationCodeResponse result = apiInstance.paymentServicesTestingAccountsGETVerificationCode(paymentAccountGuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PaymentServicesApi#paymentServicesTestingAccountsGETVerificationCode");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID paymentAccountGuid = new UUID(); // UUID | 

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

import org.openapitools.client.api.PaymentServicesApi;

public class PaymentServicesApiExample {
    public static void main(String[] args) {
        PaymentServicesApi apiInstance = new PaymentServicesApi();
        UUID paymentAccountGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            GetAccountVerificationCodeResponse result = apiInstance.paymentServicesTestingAccountsGETVerificationCode(paymentAccountGuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PaymentServicesApi#paymentServicesTestingAccountsGETVerificationCode");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
PaymentServicesApi *apiInstance = [[PaymentServicesApi alloc] init];
UUID *paymentAccountGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// PaymentServices_Testing_Accounts_GET_VerificationCode
[apiInstance paymentServicesTestingAccountsGETVerificationCodeWith:paymentAccountGuid
              completionHandler: ^(GetAccountVerificationCodeResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.PaymentServicesApi()
var paymentAccountGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.paymentServicesTestingAccountsGETVerificationCode(paymentAccountGuid, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new PaymentServicesApi();
            var paymentAccountGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // PaymentServices_Testing_Accounts_GET_VerificationCode
                GetAccountVerificationCodeResponse result = apiInstance.paymentServicesTestingAccountsGETVerificationCode(paymentAccountGuid);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PaymentServicesApi.paymentServicesTestingAccountsGETVerificationCode: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PaymentServicesApi();
$paymentAccountGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PaymentServicesApi->new();
my $paymentAccountGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->paymentServicesTestingAccountsGETVerificationCode(paymentAccountGuid => $paymentAccountGuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PaymentServicesApi->paymentServicesTestingAccountsGETVerificationCode: $@\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.PaymentServicesApi()
paymentAccountGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # PaymentServices_Testing_Accounts_GET_VerificationCode
    api_response = api_instance.payment_services_testing_accounts_get_verification_code(paymentAccountGuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PaymentServicesApi->paymentServicesTestingAccountsGETVerificationCode: %s\n" % e)
extern crate PaymentServicesApi;

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

    let mut context = PaymentServicesApi::Context::default();
    let result = client.paymentServicesTestingAccountsGETVerificationCode(paymentAccountGuid, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
paymentAccountGuid*
UUID (uuid)
Required

Responses


Public

tenantsTestingGETUserByEmailAddress

Tenants_Testing_GET_UserByEmailAddress

Retrieves single user by email address.


/v3/tenants/testing/users

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,application/problem+json" \
 "https://api.dev.spenda.co/api/v3/tenants/testing/users?emailAddress=emailAddress_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PublicApi;

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

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

        // Create an instance of the API class
        PublicApi apiInstance = new PublicApi();
        String emailAddress = emailAddress_example; // String | 

        try {
            GetUserResponse result = apiInstance.tenantsTestingGETUserByEmailAddress(emailAddress);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicApi#tenantsTestingGETUserByEmailAddress");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.PublicApi;

public class PublicApiExample {
    public static void main(String[] args) {
        PublicApi apiInstance = new PublicApi();
        String emailAddress = emailAddress_example; // String | 

        try {
            GetUserResponse result = apiInstance.tenantsTestingGETUserByEmailAddress(emailAddress);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicApi#tenantsTestingGETUserByEmailAddress");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
PublicApi *apiInstance = [[PublicApi alloc] init];
String *emailAddress = emailAddress_example; //  (default to null)

// Tenants_Testing_GET_UserByEmailAddress
[apiInstance tenantsTestingGETUserByEmailAddressWith:emailAddress
              completionHandler: ^(GetUserResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.PublicApi()
var emailAddress = emailAddress_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.tenantsTestingGETUserByEmailAddress(emailAddress, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new PublicApi();
            var emailAddress = emailAddress_example;  // String |  (default to null)

            try {
                // Tenants_Testing_GET_UserByEmailAddress
                GetUserResponse result = apiInstance.tenantsTestingGETUserByEmailAddress(emailAddress);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PublicApi.tenantsTestingGETUserByEmailAddress: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PublicApi();
$emailAddress = emailAddress_example; // String | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PublicApi->new();
my $emailAddress = emailAddress_example; # String | 

eval {
    my $result = $api_instance->tenantsTestingGETUserByEmailAddress(emailAddress => $emailAddress);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PublicApi->tenantsTestingGETUserByEmailAddress: $@\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.PublicApi()
emailAddress = emailAddress_example # String |  (default to null)

try:
    # Tenants_Testing_GET_UserByEmailAddress
    api_response = api_instance.tenants_testing_get_user_by_email_address(emailAddress)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PublicApi->tenantsTestingGETUserByEmailAddress: %s\n" % e)
extern crate PublicApi;

pub fn main() {
    let emailAddress = emailAddress_example; // String

    let mut context = PublicApi::Context::default();
    let result = client.tenantsTestingGETUserByEmailAddress(emailAddress, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
emailAddress*
String
Required

Responses


tenantsTestingPOSTNewTenant

Tenants_Testing_POST_NewTenant

Creates and onboards a new tenant using the provided details.


/v3/tenants/testing

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json,application/problem+json" \
 -H "Content-Type: application/json" \
 "https://api.dev.spenda.co/api/v3/tenants/testing" \
 -d '{
  "primaryUser" : {
    "firstName" : "firstName",
    "lastName" : "lastName",
    "emailAddress" : "emailAddress"
  },
  "name" : "name",
  "abn" : "abn",
  "defaultBillingAddress" : ""
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PublicApi;

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

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

        // Create an instance of the API class
        PublicApi apiInstance = new PublicApi();
        CreateAndOnboardTenantRequest createAndOnboardTenantRequest = {"name":"string","primaryUser":{"emailAddress":"string","firstName":"string","lastName":"string"},"abn":"string","defaultBillingAddress":{}}; // CreateAndOnboardTenantRequest | 

        try {
            CreateAndOnboardTenantResponse result = apiInstance.tenantsTestingPOSTNewTenant(createAndOnboardTenantRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicApi#tenantsTestingPOSTNewTenant");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreateAndOnboardTenantRequest createAndOnboardTenantRequest = new CreateAndOnboardTenantRequest(); // CreateAndOnboardTenantRequest | 

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

import org.openapitools.client.api.PublicApi;

public class PublicApiExample {
    public static void main(String[] args) {
        PublicApi apiInstance = new PublicApi();
        CreateAndOnboardTenantRequest createAndOnboardTenantRequest = {"name":"string","primaryUser":{"emailAddress":"string","firstName":"string","lastName":"string"},"abn":"string","defaultBillingAddress":{}}; // CreateAndOnboardTenantRequest | 

        try {
            CreateAndOnboardTenantResponse result = apiInstance.tenantsTestingPOSTNewTenant(createAndOnboardTenantRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PublicApi#tenantsTestingPOSTNewTenant");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
PublicApi *apiInstance = [[PublicApi alloc] init];
CreateAndOnboardTenantRequest *createAndOnboardTenantRequest = {"name":"string","primaryUser":{"emailAddress":"string","firstName":"string","lastName":"string"},"abn":"string","defaultBillingAddress":{}}; //  (optional)

// Tenants_Testing_POST_NewTenant
[apiInstance tenantsTestingPOSTNewTenantWith:createAndOnboardTenantRequest
              completionHandler: ^(CreateAndOnboardTenantResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.PublicApi()
var opts = {
  'createAndOnboardTenantRequest': {"name":"string","primaryUser":{"emailAddress":"string","firstName":"string","lastName":"string"},"abn":"string","defaultBillingAddress":{}} // {CreateAndOnboardTenantRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.tenantsTestingPOSTNewTenant(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new PublicApi();
            var createAndOnboardTenantRequest = new CreateAndOnboardTenantRequest(); // CreateAndOnboardTenantRequest |  (optional) 

            try {
                // Tenants_Testing_POST_NewTenant
                CreateAndOnboardTenantResponse result = apiInstance.tenantsTestingPOSTNewTenant(createAndOnboardTenantRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PublicApi.tenantsTestingPOSTNewTenant: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PublicApi();
$createAndOnboardTenantRequest = {"name":"string","primaryUser":{"emailAddress":"string","firstName":"string","lastName":"string"},"abn":"string","defaultBillingAddress":{}}; // CreateAndOnboardTenantRequest | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PublicApi->new();
my $createAndOnboardTenantRequest = WWW::OPenAPIClient::Object::CreateAndOnboardTenantRequest->new(); # CreateAndOnboardTenantRequest | 

eval {
    my $result = $api_instance->tenantsTestingPOSTNewTenant(createAndOnboardTenantRequest => $createAndOnboardTenantRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PublicApi->tenantsTestingPOSTNewTenant: $@\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.PublicApi()
createAndOnboardTenantRequest = {"name":"string","primaryUser":{"emailAddress":"string","firstName":"string","lastName":"string"},"abn":"string","defaultBillingAddress":{}} # CreateAndOnboardTenantRequest |  (optional)

try:
    # Tenants_Testing_POST_NewTenant
    api_response = api_instance.tenants_testing_post_new_tenant(createAndOnboardTenantRequest=createAndOnboardTenantRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PublicApi->tenantsTestingPOSTNewTenant: %s\n" % e)
extern crate PublicApi;

pub fn main() {
    let createAndOnboardTenantRequest = {"name":"string","primaryUser":{"emailAddress":"string","firstName":"string","lastName":"string"},"abn":"string","defaultBillingAddress":{}}; // CreateAndOnboardTenantRequest

    let mut context = PublicApi::Context::default();
    let result = client.tenantsTestingPOSTNewTenant(createAndOnboardTenantRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
createAndOnboardTenantRequest

Responses


Tenants

tenantsTestingGETUserByEmailAddress

Tenants_Testing_GET_UserByEmailAddress

Retrieves single user by email address.


/v3/tenants/testing/users

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,application/problem+json" \
 "https://api.dev.spenda.co/api/v3/tenants/testing/users?emailAddress=emailAddress_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.TenantsApi;

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

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

        // Create an instance of the API class
        TenantsApi apiInstance = new TenantsApi();
        String emailAddress = emailAddress_example; // String | 

        try {
            GetUserResponse result = apiInstance.tenantsTestingGETUserByEmailAddress(emailAddress);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TenantsApi#tenantsTestingGETUserByEmailAddress");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.TenantsApi;

public class TenantsApiExample {
    public static void main(String[] args) {
        TenantsApi apiInstance = new TenantsApi();
        String emailAddress = emailAddress_example; // String | 

        try {
            GetUserResponse result = apiInstance.tenantsTestingGETUserByEmailAddress(emailAddress);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TenantsApi#tenantsTestingGETUserByEmailAddress");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
TenantsApi *apiInstance = [[TenantsApi alloc] init];
String *emailAddress = emailAddress_example; //  (default to null)

// Tenants_Testing_GET_UserByEmailAddress
[apiInstance tenantsTestingGETUserByEmailAddressWith:emailAddress
              completionHandler: ^(GetUserResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.TenantsApi()
var emailAddress = emailAddress_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.tenantsTestingGETUserByEmailAddress(emailAddress, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new TenantsApi();
            var emailAddress = emailAddress_example;  // String |  (default to null)

            try {
                // Tenants_Testing_GET_UserByEmailAddress
                GetUserResponse result = apiInstance.tenantsTestingGETUserByEmailAddress(emailAddress);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TenantsApi.tenantsTestingGETUserByEmailAddress: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TenantsApi();
$emailAddress = emailAddress_example; // String | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TenantsApi->new();
my $emailAddress = emailAddress_example; # String | 

eval {
    my $result = $api_instance->tenantsTestingGETUserByEmailAddress(emailAddress => $emailAddress);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TenantsApi->tenantsTestingGETUserByEmailAddress: $@\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.TenantsApi()
emailAddress = emailAddress_example # String |  (default to null)

try:
    # Tenants_Testing_GET_UserByEmailAddress
    api_response = api_instance.tenants_testing_get_user_by_email_address(emailAddress)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TenantsApi->tenantsTestingGETUserByEmailAddress: %s\n" % e)
extern crate TenantsApi;

pub fn main() {
    let emailAddress = emailAddress_example; // String

    let mut context = TenantsApi::Context::default();
    let result = client.tenantsTestingGETUserByEmailAddress(emailAddress, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
emailAddress*
String
Required

Responses


tenantsTestingPOSTNewTenant

Tenants_Testing_POST_NewTenant

Creates and onboards a new tenant using the provided details.


/v3/tenants/testing

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json,application/problem+json" \
 -H "Content-Type: application/json" \
 "https://api.dev.spenda.co/api/v3/tenants/testing" \
 -d '{
  "primaryUser" : {
    "firstName" : "firstName",
    "lastName" : "lastName",
    "emailAddress" : "emailAddress"
  },
  "name" : "name",
  "abn" : "abn",
  "defaultBillingAddress" : ""
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.TenantsApi;

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

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

        // Create an instance of the API class
        TenantsApi apiInstance = new TenantsApi();
        CreateAndOnboardTenantRequest createAndOnboardTenantRequest = {"name":"string","primaryUser":{"emailAddress":"string","firstName":"string","lastName":"string"},"abn":"string","defaultBillingAddress":{}}; // CreateAndOnboardTenantRequest | 

        try {
            CreateAndOnboardTenantResponse result = apiInstance.tenantsTestingPOSTNewTenant(createAndOnboardTenantRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TenantsApi#tenantsTestingPOSTNewTenant");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreateAndOnboardTenantRequest createAndOnboardTenantRequest = new CreateAndOnboardTenantRequest(); // CreateAndOnboardTenantRequest | 

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

import org.openapitools.client.api.TenantsApi;

public class TenantsApiExample {
    public static void main(String[] args) {
        TenantsApi apiInstance = new TenantsApi();
        CreateAndOnboardTenantRequest createAndOnboardTenantRequest = {"name":"string","primaryUser":{"emailAddress":"string","firstName":"string","lastName":"string"},"abn":"string","defaultBillingAddress":{}}; // CreateAndOnboardTenantRequest | 

        try {
            CreateAndOnboardTenantResponse result = apiInstance.tenantsTestingPOSTNewTenant(createAndOnboardTenantRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TenantsApi#tenantsTestingPOSTNewTenant");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
TenantsApi *apiInstance = [[TenantsApi alloc] init];
CreateAndOnboardTenantRequest *createAndOnboardTenantRequest = {"name":"string","primaryUser":{"emailAddress":"string","firstName":"string","lastName":"string"},"abn":"string","defaultBillingAddress":{}}; //  (optional)

// Tenants_Testing_POST_NewTenant
[apiInstance tenantsTestingPOSTNewTenantWith:createAndOnboardTenantRequest
              completionHandler: ^(CreateAndOnboardTenantResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.TenantsApi()
var opts = {
  'createAndOnboardTenantRequest': {"name":"string","primaryUser":{"emailAddress":"string","firstName":"string","lastName":"string"},"abn":"string","defaultBillingAddress":{}} // {CreateAndOnboardTenantRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.tenantsTestingPOSTNewTenant(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new TenantsApi();
            var createAndOnboardTenantRequest = new CreateAndOnboardTenantRequest(); // CreateAndOnboardTenantRequest |  (optional) 

            try {
                // Tenants_Testing_POST_NewTenant
                CreateAndOnboardTenantResponse result = apiInstance.tenantsTestingPOSTNewTenant(createAndOnboardTenantRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TenantsApi.tenantsTestingPOSTNewTenant: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TenantsApi();
$createAndOnboardTenantRequest = {"name":"string","primaryUser":{"emailAddress":"string","firstName":"string","lastName":"string"},"abn":"string","defaultBillingAddress":{}}; // CreateAndOnboardTenantRequest | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TenantsApi->new();
my $createAndOnboardTenantRequest = WWW::OPenAPIClient::Object::CreateAndOnboardTenantRequest->new(); # CreateAndOnboardTenantRequest | 

eval {
    my $result = $api_instance->tenantsTestingPOSTNewTenant(createAndOnboardTenantRequest => $createAndOnboardTenantRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TenantsApi->tenantsTestingPOSTNewTenant: $@\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.TenantsApi()
createAndOnboardTenantRequest = {"name":"string","primaryUser":{"emailAddress":"string","firstName":"string","lastName":"string"},"abn":"string","defaultBillingAddress":{}} # CreateAndOnboardTenantRequest |  (optional)

try:
    # Tenants_Testing_POST_NewTenant
    api_response = api_instance.tenants_testing_post_new_tenant(createAndOnboardTenantRequest=createAndOnboardTenantRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TenantsApi->tenantsTestingPOSTNewTenant: %s\n" % e)
extern crate TenantsApi;

pub fn main() {
    let createAndOnboardTenantRequest = {"name":"string","primaryUser":{"emailAddress":"string","firstName":"string","lastName":"string"},"abn":"string","defaultBillingAddress":{}}; // CreateAndOnboardTenantRequest

    let mut context = TenantsApi::Context::default();
    let result = client.tenantsTestingPOSTNewTenant(createAndOnboardTenantRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
createAndOnboardTenantRequest

Responses


Testing

aPTestingPaymentBatchPUT

AP_Testing_PaymentBatch_PUT

Updates an existing Payment.


/v3/ap/testing/PaymentBatch

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json,application/problem+json" \
 -H "Content-Type: application/json" \
 "https://api.dev.spenda.co/api/v3/ap/testing/PaymentBatch" \
 -d '{
  "batchGuid" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "createdDate" : "2000-01-23T04:56:07.000+00:00",
  "dbStatus" : "dbStatus"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.TestingApi;

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

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

        // Create an instance of the API class
        TestingApi apiInstance = new TestingApi();
        UpdatePaymentBatchRequest updatePaymentBatchRequest = {"batchGuid":"string","dbStatus":"string","createdDate":"string"}; // UpdatePaymentBatchRequest | 

        try {
            Object result = apiInstance.aPTestingPaymentBatchPUT(updatePaymentBatchRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TestingApi#aPTestingPaymentBatchPUT");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UpdatePaymentBatchRequest updatePaymentBatchRequest = new UpdatePaymentBatchRequest(); // UpdatePaymentBatchRequest | 

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

import org.openapitools.client.api.TestingApi;

public class TestingApiExample {
    public static void main(String[] args) {
        TestingApi apiInstance = new TestingApi();
        UpdatePaymentBatchRequest updatePaymentBatchRequest = {"batchGuid":"string","dbStatus":"string","createdDate":"string"}; // UpdatePaymentBatchRequest | 

        try {
            Object result = apiInstance.aPTestingPaymentBatchPUT(updatePaymentBatchRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TestingApi#aPTestingPaymentBatchPUT");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
TestingApi *apiInstance = [[TestingApi alloc] init];
UpdatePaymentBatchRequest *updatePaymentBatchRequest = {"batchGuid":"string","dbStatus":"string","createdDate":"string"}; //  (optional)

// AP_Testing_PaymentBatch_PUT
[apiInstance aPTestingPaymentBatchPUTWith:updatePaymentBatchRequest
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.TestingApi()
var opts = {
  'updatePaymentBatchRequest': {"batchGuid":"string","dbStatus":"string","createdDate":"string"} // {UpdatePaymentBatchRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.aPTestingPaymentBatchPUT(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new TestingApi();
            var updatePaymentBatchRequest = new UpdatePaymentBatchRequest(); // UpdatePaymentBatchRequest |  (optional) 

            try {
                // AP_Testing_PaymentBatch_PUT
                Object result = apiInstance.aPTestingPaymentBatchPUT(updatePaymentBatchRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TestingApi.aPTestingPaymentBatchPUT: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TestingApi();
$updatePaymentBatchRequest = {"batchGuid":"string","dbStatus":"string","createdDate":"string"}; // UpdatePaymentBatchRequest | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TestingApi->new();
my $updatePaymentBatchRequest = WWW::OPenAPIClient::Object::UpdatePaymentBatchRequest->new(); # UpdatePaymentBatchRequest | 

eval {
    my $result = $api_instance->aPTestingPaymentBatchPUT(updatePaymentBatchRequest => $updatePaymentBatchRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TestingApi->aPTestingPaymentBatchPUT: $@\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.TestingApi()
updatePaymentBatchRequest = {"batchGuid":"string","dbStatus":"string","createdDate":"string"} # UpdatePaymentBatchRequest |  (optional)

try:
    # AP_Testing_PaymentBatch_PUT
    api_response = api_instance.a_p_testing_payment_batch_put(updatePaymentBatchRequest=updatePaymentBatchRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TestingApi->aPTestingPaymentBatchPUT: %s\n" % e)
extern crate TestingApi;

pub fn main() {
    let updatePaymentBatchRequest = {"batchGuid":"string","dbStatus":"string","createdDate":"string"}; // UpdatePaymentBatchRequest

    let mut context = TestingApi::Context::default();
    let result = client.aPTestingPaymentBatchPUT(updatePaymentBatchRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
updatePaymentBatchRequest

Responses


aPTestingTransactionsPUT

AP_Testing_Transactions_PUT

Updates an existing transaction.


/v3/ap/testing/transaction

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json,application/problem+json" \
 -H "Content-Type: application/json" \
 "https://api.dev.spenda.co/api/v3/ap/testing/transaction" \
 -d '{
  "balance" : 0.8008281904610115,
  "transactionGuid" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "type" : "DebitNote",
  "status" : "status"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.TestingApi;

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

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

        // Create an instance of the API class
        TestingApi apiInstance = new TestingApi();
        UpdateTransactionRequest updateTransactionRequest = {"type":"DebitNote","transactionGuid":"string","status":"string","balance":0}; // UpdateTransactionRequest | 

        try {
            Object result = apiInstance.aPTestingTransactionsPUT(updateTransactionRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TestingApi#aPTestingTransactionsPUT");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UpdateTransactionRequest updateTransactionRequest = new UpdateTransactionRequest(); // UpdateTransactionRequest | 

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

import org.openapitools.client.api.TestingApi;

public class TestingApiExample {
    public static void main(String[] args) {
        TestingApi apiInstance = new TestingApi();
        UpdateTransactionRequest updateTransactionRequest = {"type":"DebitNote","transactionGuid":"string","status":"string","balance":0}; // UpdateTransactionRequest | 

        try {
            Object result = apiInstance.aPTestingTransactionsPUT(updateTransactionRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TestingApi#aPTestingTransactionsPUT");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
TestingApi *apiInstance = [[TestingApi alloc] init];
UpdateTransactionRequest *updateTransactionRequest = {"type":"DebitNote","transactionGuid":"string","status":"string","balance":0}; //  (optional)

// AP_Testing_Transactions_PUT
[apiInstance aPTestingTransactionsPUTWith:updateTransactionRequest
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.TestingApi()
var opts = {
  'updateTransactionRequest': {"type":"DebitNote","transactionGuid":"string","status":"string","balance":0} // {UpdateTransactionRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.aPTestingTransactionsPUT(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new TestingApi();
            var updateTransactionRequest = new UpdateTransactionRequest(); // UpdateTransactionRequest |  (optional) 

            try {
                // AP_Testing_Transactions_PUT
                Object result = apiInstance.aPTestingTransactionsPUT(updateTransactionRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TestingApi.aPTestingTransactionsPUT: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TestingApi();
$updateTransactionRequest = {"type":"DebitNote","transactionGuid":"string","status":"string","balance":0}; // UpdateTransactionRequest | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TestingApi->new();
my $updateTransactionRequest = WWW::OPenAPIClient::Object::UpdateTransactionRequest->new(); # UpdateTransactionRequest | 

eval {
    my $result = $api_instance->aPTestingTransactionsPUT(updateTransactionRequest => $updateTransactionRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TestingApi->aPTestingTransactionsPUT: $@\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.TestingApi()
updateTransactionRequest = {"type":"DebitNote","transactionGuid":"string","status":"string","balance":0} # UpdateTransactionRequest |  (optional)

try:
    # AP_Testing_Transactions_PUT
    api_response = api_instance.a_p_testing_transactions_put(updateTransactionRequest=updateTransactionRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TestingApi->aPTestingTransactionsPUT: %s\n" % e)
extern crate TestingApi;

pub fn main() {
    let updateTransactionRequest = {"type":"DebitNote","transactionGuid":"string","status":"string","balance":0}; // UpdateTransactionRequest

    let mut context = TestingApi::Context::default();
    let result = client.aPTestingTransactionsPUT(updateTransactionRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
updateTransactionRequest

Responses


connectHubTestingDELETEData

ConnectHub_Testing_DELETE_Data

When the Connection is in Test Operating Mode, deletes objects used when simulating an import from the finance system.


/v3/connectHub/testing

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json,application/problem+json" \
 "https://api.dev.spenda.co/api/v3/connectHub/testing?dataType="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.TestingApi;

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

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

        // Create an instance of the API class
        TestingApi apiInstance = new TestingApi();
        ImportDataType dataType = ; // ImportDataType | 

        try {
            Object result = apiInstance.connectHubTestingDELETEData(dataType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TestingApi#connectHubTestingDELETEData");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ImportDataType dataType = new ImportDataType(); // ImportDataType | 

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

import org.openapitools.client.api.TestingApi;

public class TestingApiExample {
    public static void main(String[] args) {
        TestingApi apiInstance = new TestingApi();
        ImportDataType dataType = ; // ImportDataType | 

        try {
            Object result = apiInstance.connectHubTestingDELETEData(dataType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TestingApi#connectHubTestingDELETEData");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
TestingApi *apiInstance = [[TestingApi alloc] init];
ImportDataType *dataType = ; //  (default to null)

// ConnectHub_Testing_DELETE_Data
[apiInstance connectHubTestingDELETEDataWith:dataType
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.TestingApi()
var dataType = ; // {ImportDataType} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.connectHubTestingDELETEData(dataType, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new TestingApi();
            var dataType = new ImportDataType(); // ImportDataType |  (default to null)

            try {
                // ConnectHub_Testing_DELETE_Data
                Object result = apiInstance.connectHubTestingDELETEData(dataType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TestingApi.connectHubTestingDELETEData: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TestingApi();
$dataType = ; // ImportDataType | 

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

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

eval {
    my $result = $api_instance->connectHubTestingDELETEData(dataType => $dataType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TestingApi->connectHubTestingDELETEData: $@\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.TestingApi()
dataType =  # ImportDataType |  (default to null)

try:
    # ConnectHub_Testing_DELETE_Data
    api_response = api_instance.connect_hub_testing_delete_data(dataType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TestingApi->connectHubTestingDELETEData: %s\n" % e)
extern crate TestingApi;

pub fn main() {
    let dataType = ; // ImportDataType

    let mut context = TestingApi::Context::default();
    let result = client.connectHubTestingDELETEData(dataType, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
dataType*
ImportDataType
Required

Responses


connectHubTestingGETAdaptor

ConnectHub_Testing_GET_Adaptor

Gets or creates a corresponding Synk'd Adaptor that will share finance system data with the ConnectHub connection.


/v3/connectHub/testing/adaptors

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,application/problem+json" \
 "https://api.dev.spenda.co/api/v3/connectHub/testing/adaptors"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.TestingApi;

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

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

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

        try {
            Adaptor result = apiInstance.connectHubTestingGETAdaptor();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TestingApi#connectHubTestingGETAdaptor");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.TestingApi;

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

        try {
            Adaptor result = apiInstance.connectHubTestingGETAdaptor();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TestingApi#connectHubTestingGETAdaptor");
            e.printStackTrace();
        }
    }
}


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

// ConnectHub_Testing_GET_Adaptor
[apiInstance connectHubTestingGETAdaptorWithCompletionHandler: 
              ^(Adaptor output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.TestingApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.connectHubTestingGETAdaptor(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                // ConnectHub_Testing_GET_Adaptor
                Adaptor result = apiInstance.connectHubTestingGETAdaptor();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TestingApi.connectHubTestingGETAdaptor: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # ConnectHub_Testing_GET_Adaptor
    api_response = api_instance.connect_hub_testing_get_adaptor()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TestingApi->connectHubTestingGETAdaptor: %s\n" % e)
extern crate TestingApi;

pub fn main() {

    let mut context = TestingApi::Context::default();
    let result = client.connectHubTestingGETAdaptor(&context).wait();

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

Scopes

Parameters

Responses


connectHubTestingGETAdaptorSyncLogs

ConnectHub_Testing_GET_Adaptor_SyncLogs

Gets the sync logs for the Synk'd Adaptor associated with the ConnectHub connection for the given data type.


/v3/connectHub/testing/adaptors/syncLogs

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,application/problem+json" \
 "https://api.dev.spenda.co/api/v3/connectHub/testing/adaptors/syncLogs?dataType="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.TestingApi;

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

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

        // Create an instance of the API class
        TestingApi apiInstance = new TestingApi();
        DataType dataType = ; // DataType | 

        try {
            array[SyncLog] result = apiInstance.connectHubTestingGETAdaptorSyncLogs(dataType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TestingApi#connectHubTestingGETAdaptorSyncLogs");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final DataType dataType = new DataType(); // DataType | 

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

import org.openapitools.client.api.TestingApi;

public class TestingApiExample {
    public static void main(String[] args) {
        TestingApi apiInstance = new TestingApi();
        DataType dataType = ; // DataType | 

        try {
            array[SyncLog] result = apiInstance.connectHubTestingGETAdaptorSyncLogs(dataType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TestingApi#connectHubTestingGETAdaptorSyncLogs");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
TestingApi *apiInstance = [[TestingApi alloc] init];
DataType *dataType = ; //  (default to null)

// ConnectHub_Testing_GET_Adaptor_SyncLogs
[apiInstance connectHubTestingGETAdaptorSyncLogsWith:dataType
              completionHandler: ^(array[SyncLog] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.TestingApi()
var dataType = ; // {DataType} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.connectHubTestingGETAdaptorSyncLogs(dataType, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new TestingApi();
            var dataType = new DataType(); // DataType |  (default to null)

            try {
                // ConnectHub_Testing_GET_Adaptor_SyncLogs
                array[SyncLog] result = apiInstance.connectHubTestingGETAdaptorSyncLogs(dataType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TestingApi.connectHubTestingGETAdaptorSyncLogs: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TestingApi();
$dataType = ; // DataType | 

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

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

eval {
    my $result = $api_instance->connectHubTestingGETAdaptorSyncLogs(dataType => $dataType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TestingApi->connectHubTestingGETAdaptorSyncLogs: $@\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.TestingApi()
dataType =  # DataType |  (default to null)

try:
    # ConnectHub_Testing_GET_Adaptor_SyncLogs
    api_response = api_instance.connect_hub_testing_get_adaptor_sync_logs(dataType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TestingApi->connectHubTestingGETAdaptorSyncLogs: %s\n" % e)
extern crate TestingApi;

pub fn main() {
    let dataType = ; // DataType

    let mut context = TestingApi::Context::default();
    let result = client.connectHubTestingGETAdaptorSyncLogs(dataType, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
dataType*
DataType
Required

Responses


connectHubTestingPATCHConnection

ConnectHub_Testing_PATCH_Connection

When the operating mode is "Test", all interaction with the finance system will be simulated.


/v3/connectHub/testing

Usage and SDK Samples

curl -X PATCH \
 -H "Accept: application/json,application/problem+json" \
 -H "Content-Type: application/json" \
 "https://api.dev.spenda.co/api/v3/connectHub/testing" \
 -d '{
  "setOperatingModeRequest" : {
    "operatingMode" : "Normal"
  },
  "$type" : "setOperatingMode"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.TestingApi;

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

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

        // Create an instance of the API class
        TestingApi apiInstance = new TestingApi();
        TestUpdateConnection testUpdateConnection = {"$type":"setOperatingMode","setOperatingModeRequest":{"operatingMode":"Normal"}}; // TestUpdateConnection | 

        try {
            TestUpdateConnectionResponse result = apiInstance.connectHubTestingPATCHConnection(testUpdateConnection);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TestingApi#connectHubTestingPATCHConnection");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final TestUpdateConnection testUpdateConnection = new TestUpdateConnection(); // TestUpdateConnection | 

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

import org.openapitools.client.api.TestingApi;

public class TestingApiExample {
    public static void main(String[] args) {
        TestingApi apiInstance = new TestingApi();
        TestUpdateConnection testUpdateConnection = {"$type":"setOperatingMode","setOperatingModeRequest":{"operatingMode":"Normal"}}; // TestUpdateConnection | 

        try {
            TestUpdateConnectionResponse result = apiInstance.connectHubTestingPATCHConnection(testUpdateConnection);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TestingApi#connectHubTestingPATCHConnection");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
TestingApi *apiInstance = [[TestingApi alloc] init];
TestUpdateConnection *testUpdateConnection = {"$type":"setOperatingMode","setOperatingModeRequest":{"operatingMode":"Normal"}}; //  (optional)

// ConnectHub_Testing_PATCH_Connection
[apiInstance connectHubTestingPATCHConnectionWith:testUpdateConnection
              completionHandler: ^(TestUpdateConnectionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.TestingApi()
var opts = {
  'testUpdateConnection': {"$type":"setOperatingMode","setOperatingModeRequest":{"operatingMode":"Normal"}} // {TestUpdateConnection} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.connectHubTestingPATCHConnection(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new TestingApi();
            var testUpdateConnection = new TestUpdateConnection(); // TestUpdateConnection |  (optional) 

            try {
                // ConnectHub_Testing_PATCH_Connection
                TestUpdateConnectionResponse result = apiInstance.connectHubTestingPATCHConnection(testUpdateConnection);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TestingApi.connectHubTestingPATCHConnection: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TestingApi();
$testUpdateConnection = {"$type":"setOperatingMode","setOperatingModeRequest":{"operatingMode":"Normal"}}; // TestUpdateConnection | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TestingApi->new();
my $testUpdateConnection = WWW::OPenAPIClient::Object::TestUpdateConnection->new(); # TestUpdateConnection | 

eval {
    my $result = $api_instance->connectHubTestingPATCHConnection(testUpdateConnection => $testUpdateConnection);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TestingApi->connectHubTestingPATCHConnection: $@\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.TestingApi()
testUpdateConnection = {"$type":"setOperatingMode","setOperatingModeRequest":{"operatingMode":"Normal"}} # TestUpdateConnection |  (optional)

try:
    # ConnectHub_Testing_PATCH_Connection
    api_response = api_instance.connect_hub_testing_patch_connection(testUpdateConnection=testUpdateConnection)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TestingApi->connectHubTestingPATCHConnection: %s\n" % e)
extern crate TestingApi;

pub fn main() {
    let testUpdateConnection = {"$type":"setOperatingMode","setOperatingModeRequest":{"operatingMode":"Normal"}}; // TestUpdateConnection

    let mut context = TestingApi::Context::default();
    let result = client.connectHubTestingPATCHConnection(testUpdateConnection, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
testUpdateConnection

Responses


connectHubTestingPOSTData

ConnectHub_Testing_POST_Data

When the Connection is in Test Operating Mode, writes a collection of objects to be used when simulating an import from the finance system.


/v3/connectHub/testing

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json,application/problem+json" \
 -H "Content-Type: application/json" \
 "https://api.dev.spenda.co/api/v3/connectHub/testing" \
 -d '{
  "dataType" : "Supplier",
  "jsonValues" : [ "jsonValues", "jsonValues" ]
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.TestingApi;

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

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

        // Create an instance of the API class
        TestingApi apiInstance = new TestingApi();
        WriteTestDataRequest writeTestDataRequest = {"dataType":"Supplier","jsonValues":["string"]}; // WriteTestDataRequest | 

        try {
            Object result = apiInstance.connectHubTestingPOSTData(writeTestDataRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TestingApi#connectHubTestingPOSTData");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final WriteTestDataRequest writeTestDataRequest = new WriteTestDataRequest(); // WriteTestDataRequest | 

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

import org.openapitools.client.api.TestingApi;

public class TestingApiExample {
    public static void main(String[] args) {
        TestingApi apiInstance = new TestingApi();
        WriteTestDataRequest writeTestDataRequest = {"dataType":"Supplier","jsonValues":["string"]}; // WriteTestDataRequest | 

        try {
            Object result = apiInstance.connectHubTestingPOSTData(writeTestDataRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TestingApi#connectHubTestingPOSTData");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
TestingApi *apiInstance = [[TestingApi alloc] init];
WriteTestDataRequest *writeTestDataRequest = {"dataType":"Supplier","jsonValues":["string"]}; //  (optional)

// ConnectHub_Testing_POST_Data
[apiInstance connectHubTestingPOSTDataWith:writeTestDataRequest
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.TestingApi()
var opts = {
  'writeTestDataRequest': {"dataType":"Supplier","jsonValues":["string"]} // {WriteTestDataRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.connectHubTestingPOSTData(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new TestingApi();
            var writeTestDataRequest = new WriteTestDataRequest(); // WriteTestDataRequest |  (optional) 

            try {
                // ConnectHub_Testing_POST_Data
                Object result = apiInstance.connectHubTestingPOSTData(writeTestDataRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TestingApi.connectHubTestingPOSTData: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TestingApi();
$writeTestDataRequest = {"dataType":"Supplier","jsonValues":["string"]}; // WriteTestDataRequest | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TestingApi->new();
my $writeTestDataRequest = WWW::OPenAPIClient::Object::WriteTestDataRequest->new(); # WriteTestDataRequest | 

eval {
    my $result = $api_instance->connectHubTestingPOSTData(writeTestDataRequest => $writeTestDataRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TestingApi->connectHubTestingPOSTData: $@\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.TestingApi()
writeTestDataRequest = {"dataType":"Supplier","jsonValues":["string"]} # WriteTestDataRequest |  (optional)

try:
    # ConnectHub_Testing_POST_Data
    api_response = api_instance.connect_hub_testing_post_data(writeTestDataRequest=writeTestDataRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TestingApi->connectHubTestingPOSTData: %s\n" % e)
extern crate TestingApi;

pub fn main() {
    let writeTestDataRequest = {"dataType":"Supplier","jsonValues":["string"]}; // WriteTestDataRequest

    let mut context = TestingApi::Context::default();
    let result = client.connectHubTestingPOSTData(writeTestDataRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
writeTestDataRequest

Responses


paymentServicesTestingAccountsGETVerificationCode

PaymentServices_Testing_Accounts_GET_VerificationCode

Retrieves the verification code for a payment account.


/v3/paymentServices/testing/accounts/{paymentAccountGuid}/verificationCode

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,application/problem+json" \
 "https://api.dev.spenda.co/api/v3/paymentServices/testing/accounts/{paymentAccountGuid}/verificationCode"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.TestingApi;

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

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

        // Create an instance of the API class
        TestingApi apiInstance = new TestingApi();
        UUID paymentAccountGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            GetAccountVerificationCodeResponse result = apiInstance.paymentServicesTestingAccountsGETVerificationCode(paymentAccountGuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TestingApi#paymentServicesTestingAccountsGETVerificationCode");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID paymentAccountGuid = new UUID(); // UUID | 

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

import org.openapitools.client.api.TestingApi;

public class TestingApiExample {
    public static void main(String[] args) {
        TestingApi apiInstance = new TestingApi();
        UUID paymentAccountGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            GetAccountVerificationCodeResponse result = apiInstance.paymentServicesTestingAccountsGETVerificationCode(paymentAccountGuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TestingApi#paymentServicesTestingAccountsGETVerificationCode");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
TestingApi *apiInstance = [[TestingApi alloc] init];
UUID *paymentAccountGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// PaymentServices_Testing_Accounts_GET_VerificationCode
[apiInstance paymentServicesTestingAccountsGETVerificationCodeWith:paymentAccountGuid
              completionHandler: ^(GetAccountVerificationCodeResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.TestingApi()
var paymentAccountGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.paymentServicesTestingAccountsGETVerificationCode(paymentAccountGuid, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new TestingApi();
            var paymentAccountGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // PaymentServices_Testing_Accounts_GET_VerificationCode
                GetAccountVerificationCodeResponse result = apiInstance.paymentServicesTestingAccountsGETVerificationCode(paymentAccountGuid);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TestingApi.paymentServicesTestingAccountsGETVerificationCode: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TestingApi();
$paymentAccountGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TestingApi->new();
my $paymentAccountGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->paymentServicesTestingAccountsGETVerificationCode(paymentAccountGuid => $paymentAccountGuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TestingApi->paymentServicesTestingAccountsGETVerificationCode: $@\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.TestingApi()
paymentAccountGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # PaymentServices_Testing_Accounts_GET_VerificationCode
    api_response = api_instance.payment_services_testing_accounts_get_verification_code(paymentAccountGuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TestingApi->paymentServicesTestingAccountsGETVerificationCode: %s\n" % e)
extern crate TestingApi;

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

    let mut context = TestingApi::Context::default();
    let result = client.paymentServicesTestingAccountsGETVerificationCode(paymentAccountGuid, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
paymentAccountGuid*
UUID (uuid)
Required

Responses


tenantsTestingGETUserByEmailAddress

Tenants_Testing_GET_UserByEmailAddress

Retrieves single user by email address.


/v3/tenants/testing/users

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,application/problem+json" \
 "https://api.dev.spenda.co/api/v3/tenants/testing/users?emailAddress=emailAddress_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.TestingApi;

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

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

        // Create an instance of the API class
        TestingApi apiInstance = new TestingApi();
        String emailAddress = emailAddress_example; // String | 

        try {
            GetUserResponse result = apiInstance.tenantsTestingGETUserByEmailAddress(emailAddress);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TestingApi#tenantsTestingGETUserByEmailAddress");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.TestingApi;

public class TestingApiExample {
    public static void main(String[] args) {
        TestingApi apiInstance = new TestingApi();
        String emailAddress = emailAddress_example; // String | 

        try {
            GetUserResponse result = apiInstance.tenantsTestingGETUserByEmailAddress(emailAddress);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TestingApi#tenantsTestingGETUserByEmailAddress");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
TestingApi *apiInstance = [[TestingApi alloc] init];
String *emailAddress = emailAddress_example; //  (default to null)

// Tenants_Testing_GET_UserByEmailAddress
[apiInstance tenantsTestingGETUserByEmailAddressWith:emailAddress
              completionHandler: ^(GetUserResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.TestingApi()
var emailAddress = emailAddress_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.tenantsTestingGETUserByEmailAddress(emailAddress, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new TestingApi();
            var emailAddress = emailAddress_example;  // String |  (default to null)

            try {
                // Tenants_Testing_GET_UserByEmailAddress
                GetUserResponse result = apiInstance.tenantsTestingGETUserByEmailAddress(emailAddress);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TestingApi.tenantsTestingGETUserByEmailAddress: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TestingApi();
$emailAddress = emailAddress_example; // String | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TestingApi->new();
my $emailAddress = emailAddress_example; # String | 

eval {
    my $result = $api_instance->tenantsTestingGETUserByEmailAddress(emailAddress => $emailAddress);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TestingApi->tenantsTestingGETUserByEmailAddress: $@\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.TestingApi()
emailAddress = emailAddress_example # String |  (default to null)

try:
    # Tenants_Testing_GET_UserByEmailAddress
    api_response = api_instance.tenants_testing_get_user_by_email_address(emailAddress)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TestingApi->tenantsTestingGETUserByEmailAddress: %s\n" % e)
extern crate TestingApi;

pub fn main() {
    let emailAddress = emailAddress_example; // String

    let mut context = TestingApi::Context::default();
    let result = client.tenantsTestingGETUserByEmailAddress(emailAddress, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
emailAddress*
String
Required

Responses


tenantsTestingPOSTNewTenant

Tenants_Testing_POST_NewTenant

Creates and onboards a new tenant using the provided details.


/v3/tenants/testing

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json,application/problem+json" \
 -H "Content-Type: application/json" \
 "https://api.dev.spenda.co/api/v3/tenants/testing" \
 -d '{
  "primaryUser" : {
    "firstName" : "firstName",
    "lastName" : "lastName",
    "emailAddress" : "emailAddress"
  },
  "name" : "name",
  "abn" : "abn",
  "defaultBillingAddress" : ""
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.TestingApi;

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

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

        // Create an instance of the API class
        TestingApi apiInstance = new TestingApi();
        CreateAndOnboardTenantRequest createAndOnboardTenantRequest = {"name":"string","primaryUser":{"emailAddress":"string","firstName":"string","lastName":"string"},"abn":"string","defaultBillingAddress":{}}; // CreateAndOnboardTenantRequest | 

        try {
            CreateAndOnboardTenantResponse result = apiInstance.tenantsTestingPOSTNewTenant(createAndOnboardTenantRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TestingApi#tenantsTestingPOSTNewTenant");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreateAndOnboardTenantRequest createAndOnboardTenantRequest = new CreateAndOnboardTenantRequest(); // CreateAndOnboardTenantRequest | 

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

import org.openapitools.client.api.TestingApi;

public class TestingApiExample {
    public static void main(String[] args) {
        TestingApi apiInstance = new TestingApi();
        CreateAndOnboardTenantRequest createAndOnboardTenantRequest = {"name":"string","primaryUser":{"emailAddress":"string","firstName":"string","lastName":"string"},"abn":"string","defaultBillingAddress":{}}; // CreateAndOnboardTenantRequest | 

        try {
            CreateAndOnboardTenantResponse result = apiInstance.tenantsTestingPOSTNewTenant(createAndOnboardTenantRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TestingApi#tenantsTestingPOSTNewTenant");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
TestingApi *apiInstance = [[TestingApi alloc] init];
CreateAndOnboardTenantRequest *createAndOnboardTenantRequest = {"name":"string","primaryUser":{"emailAddress":"string","firstName":"string","lastName":"string"},"abn":"string","defaultBillingAddress":{}}; //  (optional)

// Tenants_Testing_POST_NewTenant
[apiInstance tenantsTestingPOSTNewTenantWith:createAndOnboardTenantRequest
              completionHandler: ^(CreateAndOnboardTenantResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.TestingApi()
var opts = {
  'createAndOnboardTenantRequest': {"name":"string","primaryUser":{"emailAddress":"string","firstName":"string","lastName":"string"},"abn":"string","defaultBillingAddress":{}} // {CreateAndOnboardTenantRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.tenantsTestingPOSTNewTenant(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new TestingApi();
            var createAndOnboardTenantRequest = new CreateAndOnboardTenantRequest(); // CreateAndOnboardTenantRequest |  (optional) 

            try {
                // Tenants_Testing_POST_NewTenant
                CreateAndOnboardTenantResponse result = apiInstance.tenantsTestingPOSTNewTenant(createAndOnboardTenantRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TestingApi.tenantsTestingPOSTNewTenant: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TestingApi();
$createAndOnboardTenantRequest = {"name":"string","primaryUser":{"emailAddress":"string","firstName":"string","lastName":"string"},"abn":"string","defaultBillingAddress":{}}; // CreateAndOnboardTenantRequest | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TestingApi->new();
my $createAndOnboardTenantRequest = WWW::OPenAPIClient::Object::CreateAndOnboardTenantRequest->new(); # CreateAndOnboardTenantRequest | 

eval {
    my $result = $api_instance->tenantsTestingPOSTNewTenant(createAndOnboardTenantRequest => $createAndOnboardTenantRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TestingApi->tenantsTestingPOSTNewTenant: $@\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.TestingApi()
createAndOnboardTenantRequest = {"name":"string","primaryUser":{"emailAddress":"string","firstName":"string","lastName":"string"},"abn":"string","defaultBillingAddress":{}} # CreateAndOnboardTenantRequest |  (optional)

try:
    # Tenants_Testing_POST_NewTenant
    api_response = api_instance.tenants_testing_post_new_tenant(createAndOnboardTenantRequest=createAndOnboardTenantRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TestingApi->tenantsTestingPOSTNewTenant: %s\n" % e)
extern crate TestingApi;

pub fn main() {
    let createAndOnboardTenantRequest = {"name":"string","primaryUser":{"emailAddress":"string","firstName":"string","lastName":"string"},"abn":"string","defaultBillingAddress":{}}; // CreateAndOnboardTenantRequest

    let mut context = TestingApi::Context::default();
    let result = client.tenantsTestingPOSTNewTenant(createAndOnboardTenantRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
createAndOnboardTenantRequest

Responses