DigitalEuroNextAPI.eu

CoreFundingApi

requestFundingDCA

Submit a funding request using DCA.

Response containing the final settlement result. Usually called < 1s after request.


/fundingRequestDCA

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/fundingRequestDCA" \
 -d '{
  "wallet" : "wallet",
  "callbackUrl" : "http://localhost:8080/settlementResponse",
  "value" : 20,
  "intermediary" : "123456789"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CoreFundingApiApi;

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

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

        // Create an instance of the API class
        CoreFundingApiApi apiInstance = new CoreFundingApiApi();
        FundingRequestDCA fundingRequestDCA = ; // FundingRequestDCA | 

        try {
            SettlementRequestResponse result = apiInstance.requestFundingDCA(fundingRequestDCA);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreFundingApiApi#requestFundingDCA");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.CoreFundingApiApi;

public class CoreFundingApiApiExample {
    public static void main(String[] args) {
        CoreFundingApiApi apiInstance = new CoreFundingApiApi();
        FundingRequestDCA fundingRequestDCA = ; // FundingRequestDCA | 

        try {
            SettlementRequestResponse result = apiInstance.requestFundingDCA(fundingRequestDCA);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreFundingApiApi#requestFundingDCA");
            e.printStackTrace();
        }
    }
}


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

// Submit a funding request using DCA.
[apiInstance requestFundingDCAWith:fundingRequestDCA
              completionHandler: ^(SettlementRequestResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DigitalEuroNextApiEu = require('digital_euro_next_api_eu');

// Create an instance of the API class
var api = new DigitalEuroNextApiEu.CoreFundingApiApi()
var fundingRequestDCA = ; // {FundingRequestDCA} 

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

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

            // Create an instance of the API class
            var apiInstance = new CoreFundingApiApi();
            var fundingRequestDCA = new FundingRequestDCA(); // FundingRequestDCA | 

            try {
                // Submit a funding request using DCA.
                SettlementRequestResponse result = apiInstance.requestFundingDCA(fundingRequestDCA);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CoreFundingApiApi.requestFundingDCA: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CoreFundingApiApi();
$fundingRequestDCA = ; // FundingRequestDCA | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CoreFundingApiApi->new();
my $fundingRequestDCA = WWW::OPenAPIClient::Object::FundingRequestDCA->new(); # FundingRequestDCA | 

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

try:
    # Submit a funding request using DCA.
    api_response = api_instance.request_funding_dca(fundingRequestDCA)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CoreFundingApiApi->requestFundingDCA: %s\n" % e)
extern crate CoreFundingApiApi;

pub fn main() {
    let fundingRequestDCA = ; // FundingRequestDCA

    let mut context = CoreFundingApiApi::Context::default();
    let result = client.requestFundingDCA(fundingRequestDCA, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
fundingRequestDCA *

Responses


CoreSettlementApi

requestSettlement

Submit a settlement request.

Response containing the final settlement result. Usually called < 1s after request.


/settlementRequest

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/settlementRequest" \
 -d '{
  "coreTransaction" : {
    "outputs" : [ {
      "amout" : 5,
      "witnessProgramCommitment" : "GyxGucbbdZeKxDoKP86k+ByR24k="
    }, {
      "amout" : 15,
      "witnessProgramCommitment" : "KVNGhLGXy4rSxGn1c+eUN5l4Z84="
    } ],
    "inputs" : [ {
      "witnessProgramCommitment" : "witnessProgramCommitment",
      "amount" : 100,
      "serialNumber" : "serialNumber"
    }, {
      "witnessProgramCommitment" : "witnessProgramCommitment",
      "amount" : 100,
      "serialNumber" : "serialNumber"
    }, {
      "witnessProgramCommitment" : "witnessProgramCommitment",
      "amount" : 100,
      "serialNumber" : "serialNumber"
    }, {
      "witnessProgramCommitment" : "witnessProgramCommitment",
      "amount" : 100,
      "serialNumber" : "serialNumber"
    }, {
      "witnessProgramCommitment" : "witnessProgramCommitment",
      "amount" : 100,
      "serialNumber" : "serialNumber"
    } ],
    "witnesses" : [ {
      "witnessData" : "witnessData",
      "witnessProgram" : "witnessProgram"
    }, {
      "witnessData" : "witnessData",
      "witnessProgram" : "witnessProgram"
    }, {
      "witnessData" : "witnessData",
      "witnessProgram" : "witnessProgram"
    }, {
      "witnessData" : "witnessData",
      "witnessProgram" : "witnessProgram"
    }, {
      "witnessData" : "witnessData",
      "witnessProgram" : "witnessProgram"
    } ]
  },
  "dryRun" : false,
  "callbackUrl" : "http://localhost:8080/settlementResponse"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CoreSettlementApiApi;

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

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

        // Create an instance of the API class
        CoreSettlementApiApi apiInstance = new CoreSettlementApiApi();
        SettlementRequest settlementRequest = ; // SettlementRequest | 

        try {
            SettlementRequestResponse result = apiInstance.requestSettlement(settlementRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreSettlementApiApi#requestSettlement");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.CoreSettlementApiApi;

public class CoreSettlementApiApiExample {
    public static void main(String[] args) {
        CoreSettlementApiApi apiInstance = new CoreSettlementApiApi();
        SettlementRequest settlementRequest = ; // SettlementRequest | 

        try {
            SettlementRequestResponse result = apiInstance.requestSettlement(settlementRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreSettlementApiApi#requestSettlement");
            e.printStackTrace();
        }
    }
}


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

// Submit a settlement request.
[apiInstance requestSettlementWith:settlementRequest
              completionHandler: ^(SettlementRequestResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DigitalEuroNextApiEu = require('digital_euro_next_api_eu');

// Create an instance of the API class
var api = new DigitalEuroNextApiEu.CoreSettlementApiApi()
var settlementRequest = ; // {SettlementRequest} 

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

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

            // Create an instance of the API class
            var apiInstance = new CoreSettlementApiApi();
            var settlementRequest = new SettlementRequest(); // SettlementRequest | 

            try {
                // Submit a settlement request.
                SettlementRequestResponse result = apiInstance.requestSettlement(settlementRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CoreSettlementApiApi.requestSettlement: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CoreSettlementApiApi();
$settlementRequest = ; // SettlementRequest | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CoreSettlementApiApi->new();
my $settlementRequest = WWW::OPenAPIClient::Object::SettlementRequest->new(); # SettlementRequest | 

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

try:
    # Submit a settlement request.
    api_response = api_instance.request_settlement(settlementRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CoreSettlementApiApi->requestSettlement: %s\n" % e)
extern crate CoreSettlementApiApi;

pub fn main() {
    let settlementRequest = ; // SettlementRequest

    let mut context = CoreSettlementApiApi::Context::default();
    let result = client.requestSettlement(settlementRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
settlementRequest *

Responses


DcaFundingApi

requestFunding

Submit a funding request.

Response containing the final settlement result. Usually called < 1s after request.


/fundingRequest

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/fundingRequest" \
 -d '{
  "receiverAddress" : "receiverAddress",
  "amount" : 0,
  "iban" : "iban",
  "callbackUrl" : "http://localhost:8080/settlementResponse"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DcaFundingApiApi;

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

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

        // Create an instance of the API class
        DcaFundingApiApi apiInstance = new DcaFundingApiApi();
        FundingRequest fundingRequest = ; // FundingRequest | 

        try {
            SettlementRequestResponse result = apiInstance.requestFunding(fundingRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DcaFundingApiApi#requestFunding");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DcaFundingApiApi;

public class DcaFundingApiApiExample {
    public static void main(String[] args) {
        DcaFundingApiApi apiInstance = new DcaFundingApiApi();
        FundingRequest fundingRequest = ; // FundingRequest | 

        try {
            SettlementRequestResponse result = apiInstance.requestFunding(fundingRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DcaFundingApiApi#requestFunding");
            e.printStackTrace();
        }
    }
}


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

// Submit a funding request.
[apiInstance requestFundingWith:fundingRequest
              completionHandler: ^(SettlementRequestResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DigitalEuroNextApiEu = require('digital_euro_next_api_eu');

// Create an instance of the API class
var api = new DigitalEuroNextApiEu.DcaFundingApiApi()
var fundingRequest = ; // {FundingRequest} 

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

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

            // Create an instance of the API class
            var apiInstance = new DcaFundingApiApi();
            var fundingRequest = new FundingRequest(); // FundingRequest | 

            try {
                // Submit a funding request.
                SettlementRequestResponse result = apiInstance.requestFunding(fundingRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DcaFundingApiApi.requestFunding: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DcaFundingApiApi();
$fundingRequest = ; // FundingRequest | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DcaFundingApiApi->new();
my $fundingRequest = WWW::OPenAPIClient::Object::FundingRequest->new(); # FundingRequest | 

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

try:
    # Submit a funding request.
    api_response = api_instance.request_funding(fundingRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DcaFundingApiApi->requestFunding: %s\n" % e)
extern crate DcaFundingApiApi;

pub fn main() {
    let fundingRequest = ; // FundingRequest

    let mut context = DcaFundingApiApi::Context::default();
    let result = client.requestFunding(fundingRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
fundingRequest *

Responses


RegistrationApi

registerAddresses

Register addresses.


/addressRegistration

Usage and SDK Samples

curl -X POST \
 -H "Content-Type: application/json" \
 "http://localhost/addressRegistration" \
 -d '{
  "addresses" : [ "addresses", "addresses" ],
  "id" : "id"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RegistrationApiApi;

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

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

        // Create an instance of the API class
        RegistrationApiApi apiInstance = new RegistrationApiApi();
        AddressRegistration addressRegistration = ; // AddressRegistration | 

        try {
            apiInstance.registerAddresses(addressRegistration);
        } catch (ApiException e) {
            System.err.println("Exception when calling RegistrationApiApi#registerAddresses");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RegistrationApiApi;

public class RegistrationApiApiExample {
    public static void main(String[] args) {
        RegistrationApiApi apiInstance = new RegistrationApiApi();
        AddressRegistration addressRegistration = ; // AddressRegistration | 

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


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

// Register addresses.
[apiInstance registerAddressesWith:addressRegistration
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DigitalEuroNextApiEu = require('digital_euro_next_api_eu');

// Create an instance of the API class
var api = new DigitalEuroNextApiEu.RegistrationApiApi()
var addressRegistration = ; // {AddressRegistration} 

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

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

            // Create an instance of the API class
            var apiInstance = new RegistrationApiApi();
            var addressRegistration = new AddressRegistration(); // AddressRegistration | 

            try {
                // Register addresses.
                apiInstance.registerAddresses(addressRegistration);
            } catch (Exception e) {
                Debug.Print("Exception when calling RegistrationApiApi.registerAddresses: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RegistrationApiApi();
$addressRegistration = ; // AddressRegistration | 

try {
    $api_instance->registerAddresses($addressRegistration);
} catch (Exception $e) {
    echo 'Exception when calling RegistrationApiApi->registerAddresses: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::RegistrationApiApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RegistrationApiApi->new();
my $addressRegistration = WWW::OPenAPIClient::Object::AddressRegistration->new(); # AddressRegistration | 

eval {
    $api_instance->registerAddresses(addressRegistration => $addressRegistration);
};
if ($@) {
    warn "Exception when calling RegistrationApiApi->registerAddresses: $@\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.RegistrationApiApi()
addressRegistration =  # AddressRegistration | 

try:
    # Register addresses.
    api_instance.register_addresses(addressRegistration)
except ApiException as e:
    print("Exception when calling RegistrationApiApi->registerAddresses: %s\n" % e)
extern crate RegistrationApiApi;

pub fn main() {
    let addressRegistration = ; // AddressRegistration

    let mut context = RegistrationApiApi::Context::default();
    let result = client.registerAddresses(addressRegistration, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
addressRegistration *

Responses


updateBloomFilter

Update bloom filter.


/bloomUpdate

Usage and SDK Samples

curl -X POST \
 -H "Content-Type: application/json" \
 "http://localhost/bloomUpdate" \
 -d '{
  "id" : "id",
  "filterDiff" : "filterDiff"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RegistrationApiApi;

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

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

        // Create an instance of the API class
        RegistrationApiApi apiInstance = new RegistrationApiApi();
        FilterUpdate filterUpdate = ; // FilterUpdate | 

        try {
            apiInstance.updateBloomFilter(filterUpdate);
        } catch (ApiException e) {
            System.err.println("Exception when calling RegistrationApiApi#updateBloomFilter");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RegistrationApiApi;

public class RegistrationApiApiExample {
    public static void main(String[] args) {
        RegistrationApiApi apiInstance = new RegistrationApiApi();
        FilterUpdate filterUpdate = ; // FilterUpdate | 

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


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

// Update bloom filter.
[apiInstance updateBloomFilterWith:filterUpdate
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DigitalEuroNextApiEu = require('digital_euro_next_api_eu');

// Create an instance of the API class
var api = new DigitalEuroNextApiEu.RegistrationApiApi()
var filterUpdate = ; // {FilterUpdate} 

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

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

            // Create an instance of the API class
            var apiInstance = new RegistrationApiApi();
            var filterUpdate = new FilterUpdate(); // FilterUpdate | 

            try {
                // Update bloom filter.
                apiInstance.updateBloomFilter(filterUpdate);
            } catch (Exception e) {
                Debug.Print("Exception when calling RegistrationApiApi.updateBloomFilter: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RegistrationApiApi();
$filterUpdate = ; // FilterUpdate | 

try {
    $api_instance->updateBloomFilter($filterUpdate);
} catch (Exception $e) {
    echo 'Exception when calling RegistrationApiApi->updateBloomFilter: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::RegistrationApiApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RegistrationApiApi->new();
my $filterUpdate = WWW::OPenAPIClient::Object::FilterUpdate->new(); # FilterUpdate | 

eval {
    $api_instance->updateBloomFilter(filterUpdate => $filterUpdate);
};
if ($@) {
    warn "Exception when calling RegistrationApiApi->updateBloomFilter: $@\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.RegistrationApiApi()
filterUpdate =  # FilterUpdate | 

try:
    # Update bloom filter.
    api_instance.update_bloom_filter(filterUpdate)
except ApiException as e:
    print("Exception when calling RegistrationApiApi->updateBloomFilter: %s\n" % e)
extern crate RegistrationApiApi;

pub fn main() {
    let filterUpdate = ; // FilterUpdate

    let mut context = RegistrationApiApi::Context::default();
    let result = client.updateBloomFilter(filterUpdate, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
filterUpdate *

Responses