0G Serving Provider Broker API

Request

listRequest

This endpoint allows you to list requests


/request

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://localhost:3080/v1/request?processed=true"

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

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

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

        // Create an instance of the API class
        RequestApi apiInstance = new RequestApi();
        Boolean processed = true; // Boolean | Processed

        try {
            model.RequestList result = apiInstance.listRequest(processed);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RequestApi#listRequest");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Boolean processed = new Boolean(); // Boolean | Processed

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


import org.openapitools.client.api.RequestApi;

public class RequestApiExample {
    public static void main(String[] args) {
        RequestApi apiInstance = new RequestApi();
        Boolean processed = true; // Boolean | Processed

        try {
            model.RequestList result = apiInstance.listRequest(processed);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RequestApi#listRequest");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
RequestApi *apiInstance = [[RequestApi alloc] init];
Boolean *processed = true; // Processed (optional) (default to null)

[apiInstance listRequestWith:processed
              completionHandler: ^(model.RequestList output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var 0GServingProviderBrokerApi = require('0_g_serving_provider_broker_api');

// Create an instance of the API class
var api = new 0GServingProviderBrokerApi.RequestApi()
var opts = {
  'processed': true // {Boolean} Processed
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new RequestApi();
            var processed = true;  // Boolean | Processed (optional)  (default to null)

            try {
                model.RequestList result = apiInstance.listRequest(processed);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RequestApi.listRequest: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RequestApi();
$processed = true; // Boolean | Processed

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RequestApi->new();
my $processed = true; # Boolean | Processed

eval {
    my $result = $api_instance->listRequest(processed => $processed);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RequestApi->listRequest: $@\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.RequestApi()
processed = true # Boolean | Processed (optional) (default to null)

try:
    api_response = api_instance.list_request(processed=processed)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RequestApi->listRequest: %s\n" % e)
extern crate RequestApi;

pub fn main() {
    let processed = true; // Boolean

    let mut context = RequestApi::Context::default();
    let result = client.listRequest(processed, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
processed
Boolean
Processed

Responses

Service

deleteService

This endpoint allows you to delete service in the contract


/service/{service}

Usage and SDK Samples

curl -X DELETE \
 "http://localhost:3080/v1/service/{service}"

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

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

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

        // Create an instance of the API class
        ServiceApi apiInstance = new ServiceApi();
        String service = service_example; // String | Service name

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String service = new String(); // String | Service name

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


import org.openapitools.client.api.ServiceApi;

public class ServiceApiExample {
    public static void main(String[] args) {
        ServiceApi apiInstance = new ServiceApi();
        String service = service_example; // String | Service name

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


// Create an instance of the API class
ServiceApi *apiInstance = [[ServiceApi alloc] init];
String *service = service_example; // Service name (default to null)

[apiInstance deleteServiceWith:service
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var 0GServingProviderBrokerApi = require('0_g_serving_provider_broker_api');

// Create an instance of the API class
var api = new 0GServingProviderBrokerApi.ServiceApi()
var service = service_example; // {String} Service name

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

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

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

            // Create an instance of the API class
            var apiInstance = new ServiceApi();
            var service = service_example;  // String | Service name (default to null)

            try {
                apiInstance.deleteService(service);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServiceApi.deleteService: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServiceApi();
$service = service_example; // String | Service name

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServiceApi->new();
my $service = service_example; # String | Service name

eval {
    $api_instance->deleteService(service => $service);
};
if ($@) {
    warn "Exception when calling ServiceApi->deleteService: $@\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.ServiceApi()
service = service_example # String | Service name (default to null)

try:
    api_instance.delete_service(service)
except ApiException as e:
    print("Exception when calling ServiceApi->deleteService: %s\n" % e)
extern crate ServiceApi;

pub fn main() {
    let service = service_example; // String

    let mut context = ServiceApi::Context::default();
    let result = client.deleteService(service, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
service*
String
Service name
Required

Responses

getService

This endpoint allows you to get service by name


/service/{service}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://localhost:3080/v1/service/{service}"

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

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

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

        // Create an instance of the API class
        ServiceApi apiInstance = new ServiceApi();
        String service = service_example; // String | Service name

        try {
            model.Service result = apiInstance.getService(service);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#getService");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String service = new String(); // String | Service name

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


import org.openapitools.client.api.ServiceApi;

public class ServiceApiExample {
    public static void main(String[] args) {
        ServiceApi apiInstance = new ServiceApi();
        String service = service_example; // String | Service name

        try {
            model.Service result = apiInstance.getService(service);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#getService");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ServiceApi *apiInstance = [[ServiceApi alloc] init];
String *service = service_example; // Service name (default to null)

[apiInstance getServiceWith:service
              completionHandler: ^(model.Service output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var 0GServingProviderBrokerApi = require('0_g_serving_provider_broker_api');

// Create an instance of the API class
var api = new 0GServingProviderBrokerApi.ServiceApi()
var service = service_example; // {String} Service name

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

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

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

            // Create an instance of the API class
            var apiInstance = new ServiceApi();
            var service = service_example;  // String | Service name (default to null)

            try {
                model.Service result = apiInstance.getService(service);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServiceApi.getService: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServiceApi();
$service = service_example; // String | Service name

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServiceApi->new();
my $service = service_example; # String | Service name

eval {
    my $result = $api_instance->getService(service => $service);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServiceApi->getService: $@\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.ServiceApi()
service = service_example # String | Service name (default to null)

try:
    api_response = api_instance.get_service(service)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServiceApi->getService: %s\n" % e)
extern crate ServiceApi;

pub fn main() {
    let service = service_example; // String

    let mut context = ServiceApi::Context::default();
    let result = client.getService(service, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
service*
String
Service name
Required

Responses

listService

This endpoint allows you to list all services in the database. Compared to the output from listServiceInContract, the service.url from this endpoint is the original URL of the service, which is not public.


/service

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://localhost:3080/v1/service"

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

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

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

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

        try {
            model.ServiceList result = apiInstance.listService();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#listService");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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


import org.openapitools.client.api.ServiceApi;

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

        try {
            model.ServiceList result = apiInstance.listService();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#listService");
            e.printStackTrace();
        }
    }
}


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

[apiInstance listServiceWithCompletionHandler: 
              ^(model.ServiceList output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var 0GServingProviderBrokerApi = require('0_g_serving_provider_broker_api');

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

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

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

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

            try {
                model.ServiceList result = apiInstance.listService();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServiceApi.listService: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    api_response = api_instance.list_service()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServiceApi->listService: %s\n" % e)
extern crate ServiceApi;

pub fn main() {

    let mut context = ServiceApi::Context::default();
    let result = client.listService(&context).wait();

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

Scopes

Parameters

Responses

listServiceInContract

This endpoint allows you to list all services in the contract


/contract-service

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://localhost:3080/v1/contract-service"

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

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

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

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

        try {
            model.ServiceList result = apiInstance.listServiceInContract();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#listServiceInContract");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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


import org.openapitools.client.api.ServiceApi;

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

        try {
            model.ServiceList result = apiInstance.listServiceInContract();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#listServiceInContract");
            e.printStackTrace();
        }
    }
}


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

[apiInstance listServiceInContractWithCompletionHandler: 
              ^(model.ServiceList output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var 0GServingProviderBrokerApi = require('0_g_serving_provider_broker_api');

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

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

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

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

            try {
                model.ServiceList result = apiInstance.listServiceInContract();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServiceApi.listServiceInContract: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    api_response = api_instance.list_service_in_contract()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServiceApi->listServiceInContract: %s\n" % e)
extern crate ServiceApi;

pub fn main() {

    let mut context = ServiceApi::Context::default();
    let result = client.listServiceInContract(&context).wait();

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

Scopes

Parameters

Responses

registerService

This endpoint allows you to register service in the contract


/service

Usage and SDK Samples

curl -X POST \
 "http://localhost:3080/v1/service" \
 -d ''

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

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

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

        // Create an instance of the API class
        ServiceApi apiInstance = new ServiceApi();
        ModelService body = ; // ModelService | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ModelService body = new ModelService(); // ModelService | 

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


import org.openapitools.client.api.ServiceApi;

public class ServiceApiExample {
    public static void main(String[] args) {
        ServiceApi apiInstance = new ServiceApi();
        ModelService body = ; // ModelService | 

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


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

[apiInstance registerServiceWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var 0GServingProviderBrokerApi = require('0_g_serving_provider_broker_api');

// Create an instance of the API class
var api = new 0GServingProviderBrokerApi.ServiceApi()
var body = ; // {ModelService} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ServiceApi();
            var body = new ModelService(); // ModelService | 

            try {
                apiInstance.registerService(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServiceApi.registerService: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServiceApi();
$body = ; // ModelService | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServiceApi->new();
my $body = WWW::OPenAPIClient::Object::ModelService->new(); # ModelService | 

eval {
    $api_instance->registerService(body => $body);
};
if ($@) {
    warn "Exception when calling ServiceApi->registerService: $@\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.ServiceApi()
body =  # ModelService | 

try:
    api_instance.register_service(body)
except ApiException as e:
    print("Exception when calling ServiceApi->registerService: %s\n" % e)
extern crate ServiceApi;

pub fn main() {
    let body = ; // ModelService

    let mut context = ServiceApi::Context::default();
    let result = client.registerService(body, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
body *

body

Responses

syncServices

This endpoint allows you to synchronize all services from local database to the contract


/sync-service

Usage and SDK Samples

curl -X POST \
 "http://localhost:3080/v1/sync-service"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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


import org.openapitools.client.api.ServiceApi;

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

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


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

[apiInstance syncServicesWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var 0GServingProviderBrokerApi = require('0_g_serving_provider_broker_api');

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

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

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

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

            try {
                apiInstance.syncServices();
            } catch (Exception e) {
                Debug.Print("Exception when calling ServiceApi.syncServices: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    api_instance.sync_services()
except ApiException as e:
    print("Exception when calling ServiceApi->syncServices: %s\n" % e)
extern crate ServiceApi;

pub fn main() {

    let mut context = ServiceApi::Context::default();
    let result = client.syncServices(&context).wait();

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

Scopes

Parameters

Responses

updateService

This endpoint allows you to update service in the contract. The name attribute cannot be updated


/service/{service}

Usage and SDK Samples

curl -X PUT \
 "http://localhost:3080/v1/service/{service}" \
 -d ''

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

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

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

        // Create an instance of the API class
        ServiceApi apiInstance = new ServiceApi();
        String service = service_example; // String | Service name
        ModelService body = ; // ModelService | 

        try {
            apiInstance.updateService(service, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#updateService");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String service = new String(); // String | Service name
final ModelService body = new ModelService(); // ModelService | 

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


import org.openapitools.client.api.ServiceApi;

public class ServiceApiExample {
    public static void main(String[] args) {
        ServiceApi apiInstance = new ServiceApi();
        String service = service_example; // String | Service name
        ModelService body = ; // ModelService | 

        try {
            apiInstance.updateService(service, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#updateService");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ServiceApi *apiInstance = [[ServiceApi alloc] init];
String *service = service_example; // Service name (default to null)
ModelService *body = ; // 

[apiInstance updateServiceWith:service
    body:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var 0GServingProviderBrokerApi = require('0_g_serving_provider_broker_api');

// Create an instance of the API class
var api = new 0GServingProviderBrokerApi.ServiceApi()
var service = service_example; // {String} Service name
var body = ; // {ModelService} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ServiceApi();
            var service = service_example;  // String | Service name (default to null)
            var body = new ModelService(); // ModelService | 

            try {
                apiInstance.updateService(service, body);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServiceApi.updateService: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServiceApi();
$service = service_example; // String | Service name
$body = ; // ModelService | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServiceApi->new();
my $service = service_example; # String | Service name
my $body = WWW::OPenAPIClient::Object::ModelService->new(); # ModelService | 

eval {
    $api_instance->updateService(service => $service, body => $body);
};
if ($@) {
    warn "Exception when calling ServiceApi->updateService: $@\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.ServiceApi()
service = service_example # String | Service name (default to null)
body =  # ModelService | 

try:
    api_instance.update_service(service, body)
except ApiException as e:
    print("Exception when calling ServiceApi->updateService: %s\n" % e)
extern crate ServiceApi;

pub fn main() {
    let service = service_example; // String
    let body = ; // ModelService

    let mut context = ServiceApi::Context::default();
    let result = client.updateService(service, body, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
service*
String
Service name
Required
Body parameters
Name Description
body *

body

Responses

Settle

settleFees

This endpoint allows you to settle fees for requests from users


/settle

Usage and SDK Samples

curl -X POST \
 "http://localhost:3080/v1/settle"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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


import org.openapitools.client.api.SettleApi;

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

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


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

[apiInstance settleFeesWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var 0GServingProviderBrokerApi = require('0_g_serving_provider_broker_api');

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

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

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

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

            try {
                apiInstance.settleFees();
            } catch (Exception e) {
                Debug.Print("Exception when calling SettleApi.settleFees: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    api_instance.settle_fees()
except ApiException as e:
    print("Exception when calling SettleApi->settleFees: %s\n" % e)
extern crate SettleApi;

pub fn main() {

    let mut context = SettleApi::Context::default();
    let result = client.settleFees(&context).wait();

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

Scopes

Parameters

Responses

User

getUserAccount

This endpoint allows you to get account by user address


/user/{user}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://localhost:3080/v1/user/{user}"

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

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

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

        // Create an instance of the API class
        UserApi apiInstance = new UserApi();
        String user = user_example; // String | User address

        try {
            model.User result = apiInstance.getUserAccount(user);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#getUserAccount");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String user = new String(); // String | User address

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


import org.openapitools.client.api.UserApi;

public class UserApiExample {
    public static void main(String[] args) {
        UserApi apiInstance = new UserApi();
        String user = user_example; // String | User address

        try {
            model.User result = apiInstance.getUserAccount(user);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#getUserAccount");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
UserApi *apiInstance = [[UserApi alloc] init];
String *user = user_example; // User address (default to null)

[apiInstance getUserAccountWith:user
              completionHandler: ^(model.User output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var 0GServingProviderBrokerApi = require('0_g_serving_provider_broker_api');

// Create an instance of the API class
var api = new 0GServingProviderBrokerApi.UserApi()
var user = user_example; // {String} User address

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

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

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

            // Create an instance of the API class
            var apiInstance = new UserApi();
            var user = user_example;  // String | User address (default to null)

            try {
                model.User result = apiInstance.getUserAccount(user);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserApi.getUserAccount: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserApi();
$user = user_example; // String | User address

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserApi->new();
my $user = user_example; # String | User address

eval {
    my $result = $api_instance->getUserAccount(user => $user);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserApi->getUserAccount: $@\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.UserApi()
user = user_example # String | User address (default to null)

try:
    api_response = api_instance.get_user_account(user)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserApi->getUserAccount: %s\n" % e)
extern crate UserApi;

pub fn main() {
    let user = user_example; // String

    let mut context = UserApi::Context::default();
    let result = client.getUserAccount(user, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
user*
String
User address
Required

Responses

listUserAccount

This endpoint allows you to list all users who have created accounts for your service


/user

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://localhost:3080/v1/user"

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

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

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

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

        try {
            model.UserList result = apiInstance.listUserAccount();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#listUserAccount");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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


import org.openapitools.client.api.UserApi;

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

        try {
            model.UserList result = apiInstance.listUserAccount();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#listUserAccount");
            e.printStackTrace();
        }
    }
}


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

[apiInstance listUserAccountWithCompletionHandler: 
              ^(model.UserList output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var 0GServingProviderBrokerApi = require('0_g_serving_provider_broker_api');

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

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

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

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

            try {
                model.UserList result = apiInstance.listUserAccount();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserApi.listUserAccount: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    api_response = api_instance.list_user_account()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserApi->listUserAccount: %s\n" % e)
extern crate UserApi;

pub fn main() {

    let mut context = UserApi::Context::default();
    let result = client.listUserAccount(&context).wait();

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

Scopes

Parameters

Responses

syncUserAccount

This endpoint allows you to synchronize information of single account from the contract


/user/{user}/sync

Usage and SDK Samples

curl -X POST \
 "http://localhost:3080/v1/user/{user}/sync"

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

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

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

        // Create an instance of the API class
        UserApi apiInstance = new UserApi();
        String user = user_example; // String | User address

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String user = new String(); // String | User address

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


import org.openapitools.client.api.UserApi;

public class UserApiExample {
    public static void main(String[] args) {
        UserApi apiInstance = new UserApi();
        String user = user_example; // String | User address

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


// Create an instance of the API class
UserApi *apiInstance = [[UserApi alloc] init];
String *user = user_example; // User address (default to null)

[apiInstance syncUserAccountWith:user
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var 0GServingProviderBrokerApi = require('0_g_serving_provider_broker_api');

// Create an instance of the API class
var api = new 0GServingProviderBrokerApi.UserApi()
var user = user_example; // {String} User address

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

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

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

            // Create an instance of the API class
            var apiInstance = new UserApi();
            var user = user_example;  // String | User address (default to null)

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserApi();
$user = user_example; // String | User address

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserApi->new();
my $user = user_example; # String | User address

eval {
    $api_instance->syncUserAccount(user => $user);
};
if ($@) {
    warn "Exception when calling UserApi->syncUserAccount: $@\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.UserApi()
user = user_example # String | User address (default to null)

try:
    api_instance.sync_user_account(user)
except ApiException as e:
    print("Exception when calling UserApi->syncUserAccount: %s\n" % e)
extern crate UserApi;

pub fn main() {
    let user = user_example; // String

    let mut context = UserApi::Context::default();
    let result = client.syncUserAccount(user, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
user*
String
User address
Required

Responses

syncUserAccounts

This endpoint allows you to synchronize information of all accounts from the contract


/sync-account

Usage and SDK Samples

curl -X POST \
 "http://localhost:3080/v1/sync-account"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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


import org.openapitools.client.api.UserApi;

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

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


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

[apiInstance syncUserAccountsWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var 0GServingProviderBrokerApi = require('0_g_serving_provider_broker_api');

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

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

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

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

            try {
                apiInstance.syncUserAccounts();
            } catch (Exception e) {
                Debug.Print("Exception when calling UserApi.syncUserAccounts: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    api_instance.sync_user_accounts()
except ApiException as e:
    print("Exception when calling UserApi->syncUserAccounts: %s\n" % e)
extern crate UserApi;

pub fn main() {

    let mut context = UserApi::Context::default();
    let result = client.syncUserAccounts(&context).wait();

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

Scopes

Parameters

Responses