BaaS project APIs

Authorization

jwtToken

API retrieve JWT token that is used for authorization in BaaS project APIs

/oauth2/token

Usage Examples and SDK

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://http:/oauth2/token" \
 -d '{
  "grant_type" : "password",
  "username" : "beeline_test",
  "password" : "my_beeline_test_password"
}'

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

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

public class AuthorizationApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: BasicAuth
        HttpBasicAuth BasicAuth = (HttpBasicAuth) defaultClient.getAuthentication("BasicAuth");
        BasicAuth.setUsername("YOUR USERNAME");
        BasicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AuthorizationApi apiInstance = new AuthorizationApi();
        ApiRequestJwtTokenRequest apiRequestJwtTokenRequest = ; // ApiRequestJwtTokenRequest | 

        try {
            ApiResponseJwtTokenResponse result = apiInstance.jwtToken(apiRequestJwtTokenRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthorizationApi#jwtToken");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ApiRequestJwtTokenRequest apiRequestJwtTokenRequest = new ApiRequestJwtTokenRequest(); // ApiRequestJwtTokenRequest | 

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

import org.openapitools.client.api.AuthorizationApi;

public class AuthorizationApiExample {
    public static void main(String[] args) {
        AuthorizationApi apiInstance = new AuthorizationApi();
        ApiRequestJwtTokenRequest apiRequestJwtTokenRequest = ; // ApiRequestJwtTokenRequest | 

        try {
            ApiResponseJwtTokenResponse result = apiInstance.jwtToken(apiRequestJwtTokenRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthorizationApi#jwtToken");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: BasicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

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

[apiInstance jwtTokenWith:apiRequestJwtTokenRequest
              completionHandler: ^(ApiResponseJwtTokenResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BaaSProjectApis = require('baa_s_project_apis');
var defaultClient = BaaSProjectApis.ApiClient.instance;

// Configure HTTP basic authorization: BasicAuth
var BasicAuth = defaultClient.authentications['BasicAuth'];
BasicAuth.username = 'YOUR USERNAME';
BasicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new BaaSProjectApis.AuthorizationApi()
var apiRequestJwtTokenRequest = ; // {ApiRequestJwtTokenRequest} 

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

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

namespace Example
{
    public class jwtTokenExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: BasicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AuthorizationApi();
            var apiRequestJwtTokenRequest = new ApiRequestJwtTokenRequest(); // ApiRequestJwtTokenRequest | 

            try {
                ApiResponseJwtTokenResponse result = apiInstance.jwtToken(apiRequestJwtTokenRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthorizationApi.jwtToken: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: BasicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthorizationApi();
$apiRequestJwtTokenRequest = ; // ApiRequestJwtTokenRequest | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AuthorizationApi;
# Configure HTTP basic authorization: BasicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthorizationApi->new();
my $apiRequestJwtTokenRequest = WWW::OPenAPIClient::Object::ApiRequestJwtTokenRequest->new(); # ApiRequestJwtTokenRequest | 

eval {
    my $result = $api_instance->jwtToken(apiRequestJwtTokenRequest => $apiRequestJwtTokenRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthorizationApi->jwtToken: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: BasicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AuthorizationApi()
apiRequestJwtTokenRequest =  # ApiRequestJwtTokenRequest | 

try:
    api_response = api_instance.ajwt_token(apiRequestJwtTokenRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthorizationApi->jwtToken: %s\n" % e)

extern crate AuthorizationApi;

pub fn main() {
    let apiRequestJwtTokenRequest = ; // ApiRequestJwtTokenRequest

    let mut context = AuthorizationApi::Context::default();
    let result = client.jwtToken(apiRequestJwtTokenRequest, &context).wait();

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

Scopes

Parameters

Body

Name	Description
apiRequestJwtTokenRequest *

Responses

Schema

CardController

cardsByPinfl

Returns client list of ordered cards in bank and list of attached cards in BaaS system

/cards/by-pin

Usage Examples and SDK

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://http:/cards/by-pin" \
 -d '{
  "id" : "c41895d9-3517-4eae-9381-94a9b9775af5",
  "params" : {
    "pinfl" : "50101009900321"
  }
}'

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

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

public class CardControllerApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        CardControllerApi apiInstance = new CardControllerApi();
        ApiRequestCardByPinflRequest apiRequestCardByPinflRequest = ; // ApiRequestCardByPinflRequest | 

        try {
            ApiResponseCardByPinflResponse result = apiInstance.cardsByPinfl(apiRequestCardByPinflRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CardControllerApi#cardsByPinfl");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ApiRequestCardByPinflRequest apiRequestCardByPinflRequest = new ApiRequestCardByPinflRequest(); // ApiRequestCardByPinflRequest | 

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

import org.openapitools.client.api.CardControllerApi;

public class CardControllerApiExample {
    public static void main(String[] args) {
        CardControllerApi apiInstance = new CardControllerApi();
        ApiRequestCardByPinflRequest apiRequestCardByPinflRequest = ; // ApiRequestCardByPinflRequest | 

        try {
            ApiResponseCardByPinflResponse result = apiInstance.cardsByPinfl(apiRequestCardByPinflRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CardControllerApi#cardsByPinfl");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

[apiInstance cardsByPinflWith:apiRequestCardByPinflRequest
              completionHandler: ^(ApiResponseCardByPinflResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BaaSProjectApis = require('baa_s_project_apis');
var defaultClient = BaaSProjectApis.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new BaaSProjectApis.CardControllerApi()
var apiRequestCardByPinflRequest = ; // {ApiRequestCardByPinflRequest} 

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

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

namespace Example
{
    public class cardsByPinflExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new CardControllerApi();
            var apiRequestCardByPinflRequest = new ApiRequestCardByPinflRequest(); // ApiRequestCardByPinflRequest | 

            try {
                ApiResponseCardByPinflResponse result = apiInstance.cardsByPinfl(apiRequestCardByPinflRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CardControllerApi.cardsByPinfl: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CardControllerApi();
$apiRequestCardByPinflRequest = ; // ApiRequestCardByPinflRequest | 

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

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

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CardControllerApi->new();
my $apiRequestCardByPinflRequest = WWW::OPenAPIClient::Object::ApiRequestCardByPinflRequest->new(); # ApiRequestCardByPinflRequest | 

eval {
    my $result = $api_instance->cardsByPinfl(apiRequestCardByPinflRequest => $apiRequestCardByPinflRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CardControllerApi->cardsByPinfl: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.CardControllerApi()
apiRequestCardByPinflRequest =  # ApiRequestCardByPinflRequest | 

try:
    api_response = api_instance.acards_by_pinfl(apiRequestCardByPinflRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CardControllerApi->cardsByPinfl: %s\n" % e)

extern crate CardControllerApi;

pub fn main() {
    let apiRequestCardByPinflRequest = ; // ApiRequestCardByPinflRequest

    let mut context = CardControllerApi::Context::default();
    let result = client.cardsByPinfl(apiRequestCardByPinflRequest, &context).wait();

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

Scopes

Parameters

Body

Name	Description
apiRequestCardByPinflRequest *

Responses

Schema

attachCard

/cards/attach

Usage Examples and SDK

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://http:/cards/attach" \
 -d '{
  "id" : "bff57baf-94e4-4998-b324-5003d941bcbd",
  "params" : {
    "pan" : "9860010100001111",
    "expiry" : "0330",
    "processingType" : "HUMO",
    "phoneNumber" : "998991112200"
  }
}'

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

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

public class CardControllerApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        CardControllerApi apiInstance = new CardControllerApi();
        ApiRequestAttachCardRequest apiRequestAttachCardRequest = ; // ApiRequestAttachCardRequest | 

        try {
            ApiResponseAttachCardResponse result = apiInstance.attachCard(apiRequestAttachCardRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CardControllerApi#attachCard");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ApiRequestAttachCardRequest apiRequestAttachCardRequest = new ApiRequestAttachCardRequest(); // ApiRequestAttachCardRequest | 

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

import org.openapitools.client.api.CardControllerApi;

public class CardControllerApiExample {
    public static void main(String[] args) {
        CardControllerApi apiInstance = new CardControllerApi();
        ApiRequestAttachCardRequest apiRequestAttachCardRequest = ; // ApiRequestAttachCardRequest | 

        try {
            ApiResponseAttachCardResponse result = apiInstance.attachCard(apiRequestAttachCardRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CardControllerApi#attachCard");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

[apiInstance attachCardWith:apiRequestAttachCardRequest
              completionHandler: ^(ApiResponseAttachCardResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BaaSProjectApis = require('baa_s_project_apis');
var defaultClient = BaaSProjectApis.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new BaaSProjectApis.CardControllerApi()
var apiRequestAttachCardRequest = ; // {ApiRequestAttachCardRequest} 

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

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

namespace Example
{
    public class attachCardExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new CardControllerApi();
            var apiRequestAttachCardRequest = new ApiRequestAttachCardRequest(); // ApiRequestAttachCardRequest | 

            try {
                ApiResponseAttachCardResponse result = apiInstance.attachCard(apiRequestAttachCardRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CardControllerApi.attachCard: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CardControllerApi();
$apiRequestAttachCardRequest = ; // ApiRequestAttachCardRequest | 

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

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

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CardControllerApi->new();
my $apiRequestAttachCardRequest = WWW::OPenAPIClient::Object::ApiRequestAttachCardRequest->new(); # ApiRequestAttachCardRequest | 

eval {
    my $result = $api_instance->attachCard(apiRequestAttachCardRequest => $apiRequestAttachCardRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CardControllerApi->attachCard: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.CardControllerApi()
apiRequestAttachCardRequest =  # ApiRequestAttachCardRequest | 

try:
    api_response = api_instance.battach_card(apiRequestAttachCardRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CardControllerApi->attachCard: %s\n" % e)

extern crate CardControllerApi;

pub fn main() {
    let apiRequestAttachCardRequest = ; // ApiRequestAttachCardRequest

    let mut context = CardControllerApi::Context::default();
    let result = client.attachCard(apiRequestAttachCardRequest, &context).wait();

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

Scopes

Parameters

Body

Name	Description
apiRequestAttachCardRequest *

Responses

Schema

verifyCard

/cards/attach/confirm

Usage Examples and SDK

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://http:/cards/attach/confirm" \
 -d '{
  "id" : "40b2cfc4-c689-4588-b35f-a330f5d2572c",
  "params" : {
    "cardId" : "a9a2a953-20a6-4a49-b1cb-9d33ac2d490c",
    "otpCode" : "333333"
  }
}'

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

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

public class CardControllerApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        CardControllerApi apiInstance = new CardControllerApi();
        ApiRequestAttachCardConfirmRequest apiRequestAttachCardConfirmRequest = ; // ApiRequestAttachCardConfirmRequest | 

        try {
            ApiResponseAttachCardConfirmResponse result = apiInstance.verifyCard(apiRequestAttachCardConfirmRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CardControllerApi#verifyCard");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ApiRequestAttachCardConfirmRequest apiRequestAttachCardConfirmRequest = new ApiRequestAttachCardConfirmRequest(); // ApiRequestAttachCardConfirmRequest | 

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

import org.openapitools.client.api.CardControllerApi;

public class CardControllerApiExample {
    public static void main(String[] args) {
        CardControllerApi apiInstance = new CardControllerApi();
        ApiRequestAttachCardConfirmRequest apiRequestAttachCardConfirmRequest = ; // ApiRequestAttachCardConfirmRequest | 

        try {
            ApiResponseAttachCardConfirmResponse result = apiInstance.verifyCard(apiRequestAttachCardConfirmRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CardControllerApi#verifyCard");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

[apiInstance verifyCardWith:apiRequestAttachCardConfirmRequest
              completionHandler: ^(ApiResponseAttachCardConfirmResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BaaSProjectApis = require('baa_s_project_apis');
var defaultClient = BaaSProjectApis.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new BaaSProjectApis.CardControllerApi()
var apiRequestAttachCardConfirmRequest = ; // {ApiRequestAttachCardConfirmRequest} 

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

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

namespace Example
{
    public class verifyCardExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new CardControllerApi();
            var apiRequestAttachCardConfirmRequest = new ApiRequestAttachCardConfirmRequest(); // ApiRequestAttachCardConfirmRequest | 

            try {
                ApiResponseAttachCardConfirmResponse result = apiInstance.verifyCard(apiRequestAttachCardConfirmRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CardControllerApi.verifyCard: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CardControllerApi();
$apiRequestAttachCardConfirmRequest = ; // ApiRequestAttachCardConfirmRequest | 

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

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

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CardControllerApi->new();
my $apiRequestAttachCardConfirmRequest = WWW::OPenAPIClient::Object::ApiRequestAttachCardConfirmRequest->new(); # ApiRequestAttachCardConfirmRequest | 

eval {
    my $result = $api_instance->verifyCard(apiRequestAttachCardConfirmRequest => $apiRequestAttachCardConfirmRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CardControllerApi->verifyCard: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.CardControllerApi()
apiRequestAttachCardConfirmRequest =  # ApiRequestAttachCardConfirmRequest | 

try:
    api_response = api_instance.cverify_card(apiRequestAttachCardConfirmRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CardControllerApi->verifyCard: %s\n" % e)

extern crate CardControllerApi;

pub fn main() {
    let apiRequestAttachCardConfirmRequest = ; // ApiRequestAttachCardConfirmRequest

    let mut context = CardControllerApi::Context::default();
    let result = client.verifyCard(apiRequestAttachCardConfirmRequest, &context).wait();

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

Scopes

Parameters

Body

Name	Description
apiRequestAttachCardConfirmRequest *

Responses

Schema

CardOrder

registerOrderCardApplication

Creates an application for order card

/cards/order

Usage Examples and SDK

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://http:/cards/order" \
 -d '{
  "id" : "c41895d9-3517-4eae-9381-94a9b9775af5",
  "params" : {
    "externalId" : "3fa85f64-5717-4562-b3fc-2c963f66afa6",
    "phoneNumber" : "998991234567",
    "clientData" : {
      "firstName" : "ANVAR",
      "fatherName" : "MAXUTDINOVICH",
      "surname" : "XODJAYEV",
      "firstNameEn" : "ANVAR",
      "surnameEn" : "XODJAYEV",
      "fatherNameEn" : "MAXUTDINOVICH",
      "personCode" : "3569965320735",
      "gender" : "1",
      "dateOfBirth" : "23.01.1996",
      "placeOfBirth" : "BUXORO SHAHRI",
      "domicileCountry" : "860",
      "domicileRegion" : "30",
      "domicileDistrict" : "6",
      "address" : "Низомий Ганжавий МФЙ, Навои кучаси, 13-уй, дом-хонадон",
      "email" : "qwerty1111@gmail.com",
      "phoneMobile" : "998901234567",
      "docSeries" : "AD",
      "docNumber" : "9012345",
      "docType" : "0",
      "docIssuedBy" : "ЯШНОБОДСКИЙ РУВД ГОРОДА ТАШКЕНТА",
      "issueDate" : "17.10.2024",
      "docValidity" : "16.10.2034",
      "passDateExp" : "16.10.2034"
    },
    "privacyPolicyAccepted" : true,
    "termsAndConditionsAccepted" : true
  }
}'

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

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

public class CardOrderApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        CardOrderApi apiInstance = new CardOrderApi();
        ApiRequestCardOrderParams apiRequestCardOrderParams = ; // ApiRequestCardOrderParams | 

        try {
            ApiResponseCardOrderResult result = apiInstance.registerOrderCardApplication(apiRequestCardOrderParams);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CardOrderApi#registerOrderCardApplication");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ApiRequestCardOrderParams apiRequestCardOrderParams = new ApiRequestCardOrderParams(); // ApiRequestCardOrderParams | 

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

import org.openapitools.client.api.CardOrderApi;

public class CardOrderApiExample {
    public static void main(String[] args) {
        CardOrderApi apiInstance = new CardOrderApi();
        ApiRequestCardOrderParams apiRequestCardOrderParams = ; // ApiRequestCardOrderParams | 

        try {
            ApiResponseCardOrderResult result = apiInstance.registerOrderCardApplication(apiRequestCardOrderParams);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CardOrderApi#registerOrderCardApplication");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

[apiInstance registerOrderCardApplicationWith:apiRequestCardOrderParams
              completionHandler: ^(ApiResponseCardOrderResult output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BaaSProjectApis = require('baa_s_project_apis');
var defaultClient = BaaSProjectApis.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new BaaSProjectApis.CardOrderApi()
var apiRequestCardOrderParams = ; // {ApiRequestCardOrderParams} 

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

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

namespace Example
{
    public class registerOrderCardApplicationExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new CardOrderApi();
            var apiRequestCardOrderParams = new ApiRequestCardOrderParams(); // ApiRequestCardOrderParams | 

            try {
                ApiResponseCardOrderResult result = apiInstance.registerOrderCardApplication(apiRequestCardOrderParams);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CardOrderApi.registerOrderCardApplication: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CardOrderApi();
$apiRequestCardOrderParams = ; // ApiRequestCardOrderParams | 

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

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

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CardOrderApi->new();
my $apiRequestCardOrderParams = WWW::OPenAPIClient::Object::ApiRequestCardOrderParams->new(); # ApiRequestCardOrderParams | 

eval {
    my $result = $api_instance->registerOrderCardApplication(apiRequestCardOrderParams => $apiRequestCardOrderParams);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CardOrderApi->registerOrderCardApplication: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.CardOrderApi()
apiRequestCardOrderParams =  # ApiRequestCardOrderParams | 

try:
    api_response = api_instance.aregister_order_card_application(apiRequestCardOrderParams)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CardOrderApi->registerOrderCardApplication: %s\n" % e)

extern crate CardOrderApi;

pub fn main() {
    let apiRequestCardOrderParams = ; // ApiRequestCardOrderParams

    let mut context = CardOrderApi::Context::default();
    let result = client.registerOrderCardApplication(apiRequestCardOrderParams, &context).wait();

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

Scopes

Parameters

Body

Name	Description
apiRequestCardOrderParams *

Responses

Schema

orderCardApplicationInfo

Return information about card-order application

/cards/order/info

Usage Examples and SDK

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://http:/cards/order/info" \
 -d '{
  "id" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "params" : {
    "orderId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
  }
}'

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

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

public class CardOrderApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        CardOrderApi apiInstance = new CardOrderApi();
        ApiRequestCardOrderInfoParams apiRequestCardOrderInfoParams = ; // ApiRequestCardOrderInfoParams | 

        try {
            ApiResponseCardOrderInfoResult result = apiInstance.orderCardApplicationInfo(apiRequestCardOrderInfoParams);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CardOrderApi#orderCardApplicationInfo");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ApiRequestCardOrderInfoParams apiRequestCardOrderInfoParams = new ApiRequestCardOrderInfoParams(); // ApiRequestCardOrderInfoParams | 

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

import org.openapitools.client.api.CardOrderApi;

public class CardOrderApiExample {
    public static void main(String[] args) {
        CardOrderApi apiInstance = new CardOrderApi();
        ApiRequestCardOrderInfoParams apiRequestCardOrderInfoParams = ; // ApiRequestCardOrderInfoParams | 

        try {
            ApiResponseCardOrderInfoResult result = apiInstance.orderCardApplicationInfo(apiRequestCardOrderInfoParams);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CardOrderApi#orderCardApplicationInfo");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

[apiInstance orderCardApplicationInfoWith:apiRequestCardOrderInfoParams
              completionHandler: ^(ApiResponseCardOrderInfoResult output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BaaSProjectApis = require('baa_s_project_apis');
var defaultClient = BaaSProjectApis.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new BaaSProjectApis.CardOrderApi()
var apiRequestCardOrderInfoParams = ; // {ApiRequestCardOrderInfoParams} 

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

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

namespace Example
{
    public class orderCardApplicationInfoExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new CardOrderApi();
            var apiRequestCardOrderInfoParams = new ApiRequestCardOrderInfoParams(); // ApiRequestCardOrderInfoParams | 

            try {
                ApiResponseCardOrderInfoResult result = apiInstance.orderCardApplicationInfo(apiRequestCardOrderInfoParams);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CardOrderApi.orderCardApplicationInfo: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CardOrderApi();
$apiRequestCardOrderInfoParams = ; // ApiRequestCardOrderInfoParams | 

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

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

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CardOrderApi->new();
my $apiRequestCardOrderInfoParams = WWW::OPenAPIClient::Object::ApiRequestCardOrderInfoParams->new(); # ApiRequestCardOrderInfoParams | 

eval {
    my $result = $api_instance->orderCardApplicationInfo(apiRequestCardOrderInfoParams => $apiRequestCardOrderInfoParams);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CardOrderApi->orderCardApplicationInfo: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.CardOrderApi()
apiRequestCardOrderInfoParams =  # ApiRequestCardOrderInfoParams | 

try:
    api_response = api_instance.border_card_application_info(apiRequestCardOrderInfoParams)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CardOrderApi->orderCardApplicationInfo: %s\n" % e)

extern crate CardOrderApi;

pub fn main() {
    let apiRequestCardOrderInfoParams = ; // ApiRequestCardOrderInfoParams

    let mut context = CardOrderApi::Context::default();
    let result = client.orderCardApplicationInfo(apiRequestCardOrderInfoParams, &context).wait();

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

Scopes

Parameters

Body

Name	Description
apiRequestCardOrderInfoParams *

Responses

Schema

updateCardStatus

Change card status

/cards/status

Usage Examples and SDK

curl -X PUT \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://http:/cards/status" \
 -d '{
  "id" : "78dd0600-51bd-4f58-9066-f96251e7f652",
  "params" : {
    "cardId" : "d0684255-22a2-4516-85a6-d6d0c8ed8ba3",
    "status" : "BLOCK",
    "reason" : "Just for test"
  }
}'

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

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

public class CardOrderApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        CardOrderApi apiInstance = new CardOrderApi();
        ApiRequestCardStatusUpdateParams apiRequestCardStatusUpdateParams = ; // ApiRequestCardStatusUpdateParams | 

        try {
            ApiResponseCardStatusInfoResult result = apiInstance.updateCardStatus(apiRequestCardStatusUpdateParams);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CardOrderApi#updateCardStatus");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ApiRequestCardStatusUpdateParams apiRequestCardStatusUpdateParams = new ApiRequestCardStatusUpdateParams(); // ApiRequestCardStatusUpdateParams | 

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

import org.openapitools.client.api.CardOrderApi;

public class CardOrderApiExample {
    public static void main(String[] args) {
        CardOrderApi apiInstance = new CardOrderApi();
        ApiRequestCardStatusUpdateParams apiRequestCardStatusUpdateParams = ; // ApiRequestCardStatusUpdateParams | 

        try {
            ApiResponseCardStatusInfoResult result = apiInstance.updateCardStatus(apiRequestCardStatusUpdateParams);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CardOrderApi#updateCardStatus");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

[apiInstance updateCardStatusWith:apiRequestCardStatusUpdateParams
              completionHandler: ^(ApiResponseCardStatusInfoResult output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BaaSProjectApis = require('baa_s_project_apis');
var defaultClient = BaaSProjectApis.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new BaaSProjectApis.CardOrderApi()
var apiRequestCardStatusUpdateParams = ; // {ApiRequestCardStatusUpdateParams} 

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

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

namespace Example
{
    public class updateCardStatusExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new CardOrderApi();
            var apiRequestCardStatusUpdateParams = new ApiRequestCardStatusUpdateParams(); // ApiRequestCardStatusUpdateParams | 

            try {
                ApiResponseCardStatusInfoResult result = apiInstance.updateCardStatus(apiRequestCardStatusUpdateParams);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CardOrderApi.updateCardStatus: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CardOrderApi();
$apiRequestCardStatusUpdateParams = ; // ApiRequestCardStatusUpdateParams | 

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

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

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CardOrderApi->new();
my $apiRequestCardStatusUpdateParams = WWW::OPenAPIClient::Object::ApiRequestCardStatusUpdateParams->new(); # ApiRequestCardStatusUpdateParams | 

eval {
    my $result = $api_instance->updateCardStatus(apiRequestCardStatusUpdateParams => $apiRequestCardStatusUpdateParams);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CardOrderApi->updateCardStatus: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.CardOrderApi()
apiRequestCardStatusUpdateParams =  # ApiRequestCardStatusUpdateParams | 

try:
    api_response = api_instance.cupdate_card_status(apiRequestCardStatusUpdateParams)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CardOrderApi->updateCardStatus: %s\n" % e)

extern crate CardOrderApi;

pub fn main() {
    let apiRequestCardStatusUpdateParams = ; // ApiRequestCardStatusUpdateParams

    let mut context = CardOrderApi::Context::default();
    let result = client.updateCardStatus(apiRequestCardStatusUpdateParams, &context).wait();

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

Scopes

Parameters

Body

Name	Description
apiRequestCardStatusUpdateParams *

Responses

Schema

cardStatusInfo

Return card status

/cards/status

Usage Examples and SDK

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://http:/cards/status" \
 -d '{
  "id" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "params" : {
    "cardId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
  }
}'

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

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

public class CardOrderApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        CardOrderApi apiInstance = new CardOrderApi();
        ApiRequestCardStatusInfoParams apiRequestCardStatusInfoParams = ; // ApiRequestCardStatusInfoParams | 

        try {
            ApiResponseCardStatusInfoResult result = apiInstance.cardStatusInfo(apiRequestCardStatusInfoParams);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CardOrderApi#cardStatusInfo");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ApiRequestCardStatusInfoParams apiRequestCardStatusInfoParams = new ApiRequestCardStatusInfoParams(); // ApiRequestCardStatusInfoParams | 

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

import org.openapitools.client.api.CardOrderApi;

public class CardOrderApiExample {
    public static void main(String[] args) {
        CardOrderApi apiInstance = new CardOrderApi();
        ApiRequestCardStatusInfoParams apiRequestCardStatusInfoParams = ; // ApiRequestCardStatusInfoParams | 

        try {
            ApiResponseCardStatusInfoResult result = apiInstance.cardStatusInfo(apiRequestCardStatusInfoParams);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CardOrderApi#cardStatusInfo");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

[apiInstance cardStatusInfoWith:apiRequestCardStatusInfoParams
              completionHandler: ^(ApiResponseCardStatusInfoResult output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BaaSProjectApis = require('baa_s_project_apis');
var defaultClient = BaaSProjectApis.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new BaaSProjectApis.CardOrderApi()
var apiRequestCardStatusInfoParams = ; // {ApiRequestCardStatusInfoParams} 

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

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

namespace Example
{
    public class cardStatusInfoExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new CardOrderApi();
            var apiRequestCardStatusInfoParams = new ApiRequestCardStatusInfoParams(); // ApiRequestCardStatusInfoParams | 

            try {
                ApiResponseCardStatusInfoResult result = apiInstance.cardStatusInfo(apiRequestCardStatusInfoParams);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CardOrderApi.cardStatusInfo: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CardOrderApi();
$apiRequestCardStatusInfoParams = ; // ApiRequestCardStatusInfoParams | 

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

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

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CardOrderApi->new();
my $apiRequestCardStatusInfoParams = WWW::OPenAPIClient::Object::ApiRequestCardStatusInfoParams->new(); # ApiRequestCardStatusInfoParams | 

eval {
    my $result = $api_instance->cardStatusInfo(apiRequestCardStatusInfoParams => $apiRequestCardStatusInfoParams);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CardOrderApi->cardStatusInfo: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.CardOrderApi()
apiRequestCardStatusInfoParams =  # ApiRequestCardStatusInfoParams | 

try:
    api_response = api_instance.dcard_status_info(apiRequestCardStatusInfoParams)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CardOrderApi->cardStatusInfo: %s\n" % e)

extern crate CardOrderApi;

pub fn main() {
    let apiRequestCardStatusInfoParams = ; // ApiRequestCardStatusInfoParams

    let mut context = CardOrderApi::Context::default();
    let result = client.cardStatusInfo(apiRequestCardStatusInfoParams, &context).wait();

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

Scopes

Parameters

Body

Name	Description
apiRequestCardStatusInfoParams *

Responses

Schema

MicroloanController

registerMicroloanApplication

Register application to Pre-scoring, when pre-scoring processing is finished client get information, from other API, about it's loan limit

/microloans/applications/pre-scoring/register

Usage Examples and SDK

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://http:/microloans/applications/pre-scoring/register" \
 -d '{
  "id" : "dddc9677-4c45-490a-aee2-2194ef8a3f51",
  "params" : {
    "externalId" : "8c9461cf-ef42-47cf-b00f-64cc7c97c2c6",
    "isAgreementAccepted" : true,
    "phoneNumber" : "998901234567",
    "clientData" : {
      "firstName" : "ANVAR",
      "fatherName" : "MAXUTDINOVICH",
      "surname" : "XODJAYEV",
      "firstNameEn" : "ANVAR",
      "surnameEn" : "XODJAYEV",
      "fatherNameEn" : "MAXUTDINOVICH",
      "personCode" : "3569965320735",
      "gender" : "1",
      "dateOfBirth" : "23.01.1996",
      "placeOfBirth" : "BUXORO SHAHRI",
      "domicileCountry" : "860",
      "domicileRegion" : "30",
      "domicileDistrict" : "6",
      "address" : "Низомий Ганжавий МФЙ, Навои кучаси, 13-уй, дом-хонадон",
      "email" : "qwerty1111@gmail.com",
      "phoneMobile" : "998901234567",
      "docSeries" : "AD",
      "docNumber" : "9012345",
      "docType" : "0",
      "docIssuedBy" : "ЯШНОБОДСКИЙ РУВД ГОРОДА ТАШКЕНТА",
      "issueDate" : "17.10.2024",
      "docValidity" : "16.10.2034",
      "passDateExp" : "16.10.2034"
    }
  }
}'

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

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

public class MicroloanControllerApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        MicroloanControllerApi apiInstance = new MicroloanControllerApi();
        ApiRequestMicroLoanApplicationRequest apiRequestMicroLoanApplicationRequest = ; // ApiRequestMicroLoanApplicationRequest | 

        try {
            ApiResponseMicroLoanApplicationResponse result = apiInstance.registerMicroloanApplication(apiRequestMicroLoanApplicationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MicroloanControllerApi#registerMicroloanApplication");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ApiRequestMicroLoanApplicationRequest apiRequestMicroLoanApplicationRequest = new ApiRequestMicroLoanApplicationRequest(); // ApiRequestMicroLoanApplicationRequest | 

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

import org.openapitools.client.api.MicroloanControllerApi;

public class MicroloanControllerApiExample {
    public static void main(String[] args) {
        MicroloanControllerApi apiInstance = new MicroloanControllerApi();
        ApiRequestMicroLoanApplicationRequest apiRequestMicroLoanApplicationRequest = ; // ApiRequestMicroLoanApplicationRequest | 

        try {
            ApiResponseMicroLoanApplicationResponse result = apiInstance.registerMicroloanApplication(apiRequestMicroLoanApplicationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MicroloanControllerApi#registerMicroloanApplication");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

[apiInstance registerMicroloanApplicationWith:apiRequestMicroLoanApplicationRequest
              completionHandler: ^(ApiResponseMicroLoanApplicationResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BaaSProjectApis = require('baa_s_project_apis');
var defaultClient = BaaSProjectApis.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new BaaSProjectApis.MicroloanControllerApi()
var apiRequestMicroLoanApplicationRequest = ; // {ApiRequestMicroLoanApplicationRequest} 

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

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

namespace Example
{
    public class registerMicroloanApplicationExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new MicroloanControllerApi();
            var apiRequestMicroLoanApplicationRequest = new ApiRequestMicroLoanApplicationRequest(); // ApiRequestMicroLoanApplicationRequest | 

            try {
                ApiResponseMicroLoanApplicationResponse result = apiInstance.registerMicroloanApplication(apiRequestMicroLoanApplicationRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MicroloanControllerApi.registerMicroloanApplication: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MicroloanControllerApi();
$apiRequestMicroLoanApplicationRequest = ; // ApiRequestMicroLoanApplicationRequest | 

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

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

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MicroloanControllerApi->new();
my $apiRequestMicroLoanApplicationRequest = WWW::OPenAPIClient::Object::ApiRequestMicroLoanApplicationRequest->new(); # ApiRequestMicroLoanApplicationRequest | 

eval {
    my $result = $api_instance->registerMicroloanApplication(apiRequestMicroLoanApplicationRequest => $apiRequestMicroLoanApplicationRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MicroloanControllerApi->registerMicroloanApplication: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.MicroloanControllerApi()
apiRequestMicroLoanApplicationRequest =  # ApiRequestMicroLoanApplicationRequest | 

try:
    api_response = api_instance.aregister_microloan_application(apiRequestMicroLoanApplicationRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MicroloanControllerApi->registerMicroloanApplication: %s\n" % e)

extern crate MicroloanControllerApi;

pub fn main() {
    let apiRequestMicroLoanApplicationRequest = ; // ApiRequestMicroLoanApplicationRequest

    let mut context = MicroloanControllerApi::Context::default();
    let result = client.registerMicroloanApplication(apiRequestMicroLoanApplicationRequest, &context).wait();

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

Scopes

Parameters

Body

Name	Description
apiRequestMicroLoanApplicationRequest *

Responses

Schema

microloanApplicationInfo

Returns application information. Can be used in any stage of application processing (Pre-scoring, Post-scoring, Loan-issuing)

/microloans/applications/info

Usage Examples and SDK

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://http:/microloans/applications/info" \
 -d '{
  "id" : "c41895d9-3517-4eae-9381-94a9b9775af5",
  "params" : {
    "applicationId" : "218fc3b1-fdae-4ac6-9dab-b40c7fe20f97"
  }
}'

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

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

public class MicroloanControllerApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        MicroloanControllerApi apiInstance = new MicroloanControllerApi();
        ApiRequestMicroloanApplicationInfoRequest apiRequestMicroloanApplicationInfoRequest = ; // ApiRequestMicroloanApplicationInfoRequest | 

        try {
            ApiResponseMicroloanApplicationInfoResponse result = apiInstance.microloanApplicationInfo(apiRequestMicroloanApplicationInfoRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MicroloanControllerApi#microloanApplicationInfo");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ApiRequestMicroloanApplicationInfoRequest apiRequestMicroloanApplicationInfoRequest = new ApiRequestMicroloanApplicationInfoRequest(); // ApiRequestMicroloanApplicationInfoRequest | 

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

import org.openapitools.client.api.MicroloanControllerApi;

public class MicroloanControllerApiExample {
    public static void main(String[] args) {
        MicroloanControllerApi apiInstance = new MicroloanControllerApi();
        ApiRequestMicroloanApplicationInfoRequest apiRequestMicroloanApplicationInfoRequest = ; // ApiRequestMicroloanApplicationInfoRequest | 

        try {
            ApiResponseMicroloanApplicationInfoResponse result = apiInstance.microloanApplicationInfo(apiRequestMicroloanApplicationInfoRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MicroloanControllerApi#microloanApplicationInfo");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

[apiInstance microloanApplicationInfoWith:apiRequestMicroloanApplicationInfoRequest
              completionHandler: ^(ApiResponseMicroloanApplicationInfoResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BaaSProjectApis = require('baa_s_project_apis');
var defaultClient = BaaSProjectApis.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new BaaSProjectApis.MicroloanControllerApi()
var apiRequestMicroloanApplicationInfoRequest = ; // {ApiRequestMicroloanApplicationInfoRequest} 

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

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

namespace Example
{
    public class microloanApplicationInfoExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new MicroloanControllerApi();
            var apiRequestMicroloanApplicationInfoRequest = new ApiRequestMicroloanApplicationInfoRequest(); // ApiRequestMicroloanApplicationInfoRequest | 

            try {
                ApiResponseMicroloanApplicationInfoResponse result = apiInstance.microloanApplicationInfo(apiRequestMicroloanApplicationInfoRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MicroloanControllerApi.microloanApplicationInfo: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MicroloanControllerApi();
$apiRequestMicroloanApplicationInfoRequest = ; // ApiRequestMicroloanApplicationInfoRequest | 

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

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

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MicroloanControllerApi->new();
my $apiRequestMicroloanApplicationInfoRequest = WWW::OPenAPIClient::Object::ApiRequestMicroloanApplicationInfoRequest->new(); # ApiRequestMicroloanApplicationInfoRequest | 

eval {
    my $result = $api_instance->microloanApplicationInfo(apiRequestMicroloanApplicationInfoRequest => $apiRequestMicroloanApplicationInfoRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MicroloanControllerApi->microloanApplicationInfo: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.MicroloanControllerApi()
apiRequestMicroloanApplicationInfoRequest =  # ApiRequestMicroloanApplicationInfoRequest | 

try:
    api_response = api_instance.bmicroloan_application_info(apiRequestMicroloanApplicationInfoRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MicroloanControllerApi->microloanApplicationInfo: %s\n" % e)

extern crate MicroloanControllerApi;

pub fn main() {
    let apiRequestMicroloanApplicationInfoRequest = ; // ApiRequestMicroloanApplicationInfoRequest

    let mut context = MicroloanControllerApi::Context::default();
    let result = client.microloanApplicationInfo(apiRequestMicroloanApplicationInfoRequest, &context).wait();

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

Scopes

Parameters

Body

Name	Description
apiRequestMicroloanApplicationInfoRequest *

Responses

Schema

microloanCancel

Cancel ongoing microloan application

/microloans/applications/cancel

Usage Examples and SDK

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://http:/microloans/applications/cancel" \
 -d '{
  "id" : "3fa85f64-5717-4562-b3fc-2c963f66afa6",
  "params" : {
    "applicationId" : "ea53912f-d3c6-454e-a90d-cdad46c71687",
    "initiator" : "SYSTEM"
  }
}'

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

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

public class MicroloanControllerApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        MicroloanControllerApi apiInstance = new MicroloanControllerApi();
        ApiRequestMicroloanCancelRequest apiRequestMicroloanCancelRequest = ; // ApiRequestMicroloanCancelRequest | 

        try {
            ApiResponseMicroloanCancelResponse result = apiInstance.microloanCancel(apiRequestMicroloanCancelRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MicroloanControllerApi#microloanCancel");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ApiRequestMicroloanCancelRequest apiRequestMicroloanCancelRequest = new ApiRequestMicroloanCancelRequest(); // ApiRequestMicroloanCancelRequest | 

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

import org.openapitools.client.api.MicroloanControllerApi;

public class MicroloanControllerApiExample {
    public static void main(String[] args) {
        MicroloanControllerApi apiInstance = new MicroloanControllerApi();
        ApiRequestMicroloanCancelRequest apiRequestMicroloanCancelRequest = ; // ApiRequestMicroloanCancelRequest | 

        try {
            ApiResponseMicroloanCancelResponse result = apiInstance.microloanCancel(apiRequestMicroloanCancelRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MicroloanControllerApi#microloanCancel");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

[apiInstance microloanCancelWith:apiRequestMicroloanCancelRequest
              completionHandler: ^(ApiResponseMicroloanCancelResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BaaSProjectApis = require('baa_s_project_apis');
var defaultClient = BaaSProjectApis.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new BaaSProjectApis.MicroloanControllerApi()
var apiRequestMicroloanCancelRequest = ; // {ApiRequestMicroloanCancelRequest} 

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

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

namespace Example
{
    public class microloanCancelExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new MicroloanControllerApi();
            var apiRequestMicroloanCancelRequest = new ApiRequestMicroloanCancelRequest(); // ApiRequestMicroloanCancelRequest | 

            try {
                ApiResponseMicroloanCancelResponse result = apiInstance.microloanCancel(apiRequestMicroloanCancelRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MicroloanControllerApi.microloanCancel: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MicroloanControllerApi();
$apiRequestMicroloanCancelRequest = ; // ApiRequestMicroloanCancelRequest | 

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

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

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MicroloanControllerApi->new();
my $apiRequestMicroloanCancelRequest = WWW::OPenAPIClient::Object::ApiRequestMicroloanCancelRequest->new(); # ApiRequestMicroloanCancelRequest | 

eval {
    my $result = $api_instance->microloanCancel(apiRequestMicroloanCancelRequest => $apiRequestMicroloanCancelRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MicroloanControllerApi->microloanCancel: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.MicroloanControllerApi()
apiRequestMicroloanCancelRequest =  # ApiRequestMicroloanCancelRequest | 

try:
    api_response = api_instance.dmicroloan_cancel(apiRequestMicroloanCancelRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MicroloanControllerApi->microloanCancel: %s\n" % e)

extern crate MicroloanControllerApi;

pub fn main() {
    let apiRequestMicroloanCancelRequest = ; // ApiRequestMicroloanCancelRequest

    let mut context = MicroloanControllerApi::Context::default();
    let result = client.microloanCancel(apiRequestMicroloanCancelRequest, &context).wait();

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

Scopes

Parameters

Body

Name	Description
apiRequestMicroloanCancelRequest *

Responses

Schema

microloanVerify

When a client decides to get loan, they call the API with desired loan conditions

/microloans/applications/verify

Usage Examples and SDK

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://http:/microloans/applications/verify" \
 -d '{
  "id" : "3fa85f64-5717-4562-b3fc-2c963f66afa6",
  "params" : {
    "applicationId" : "3fa85f64-5717-4562-b3fc-2c963f66afa6",
    "amount" : 1000000000,
    "percent" : 40.0,
    "monthPeriod" : 12,
    "backupPhone" : "998991112233"
  }
}'

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

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

public class MicroloanControllerApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        MicroloanControllerApi apiInstance = new MicroloanControllerApi();
        ApiRequestMicroloanVerifyRequest apiRequestMicroloanVerifyRequest = ; // ApiRequestMicroloanVerifyRequest | 

        try {
            ApiResponseMicroloanVerifyResponse result = apiInstance.microloanVerify(apiRequestMicroloanVerifyRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MicroloanControllerApi#microloanVerify");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ApiRequestMicroloanVerifyRequest apiRequestMicroloanVerifyRequest = new ApiRequestMicroloanVerifyRequest(); // ApiRequestMicroloanVerifyRequest | 

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

import org.openapitools.client.api.MicroloanControllerApi;

public class MicroloanControllerApiExample {
    public static void main(String[] args) {
        MicroloanControllerApi apiInstance = new MicroloanControllerApi();
        ApiRequestMicroloanVerifyRequest apiRequestMicroloanVerifyRequest = ; // ApiRequestMicroloanVerifyRequest | 

        try {
            ApiResponseMicroloanVerifyResponse result = apiInstance.microloanVerify(apiRequestMicroloanVerifyRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MicroloanControllerApi#microloanVerify");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

[apiInstance microloanVerifyWith:apiRequestMicroloanVerifyRequest
              completionHandler: ^(ApiResponseMicroloanVerifyResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BaaSProjectApis = require('baa_s_project_apis');
var defaultClient = BaaSProjectApis.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new BaaSProjectApis.MicroloanControllerApi()
var apiRequestMicroloanVerifyRequest = ; // {ApiRequestMicroloanVerifyRequest} 

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

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

namespace Example
{
    public class microloanVerifyExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new MicroloanControllerApi();
            var apiRequestMicroloanVerifyRequest = new ApiRequestMicroloanVerifyRequest(); // ApiRequestMicroloanVerifyRequest | 

            try {
                ApiResponseMicroloanVerifyResponse result = apiInstance.microloanVerify(apiRequestMicroloanVerifyRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MicroloanControllerApi.microloanVerify: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MicroloanControllerApi();
$apiRequestMicroloanVerifyRequest = ; // ApiRequestMicroloanVerifyRequest | 

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

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

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MicroloanControllerApi->new();
my $apiRequestMicroloanVerifyRequest = WWW::OPenAPIClient::Object::ApiRequestMicroloanVerifyRequest->new(); # ApiRequestMicroloanVerifyRequest | 

eval {
    my $result = $api_instance->microloanVerify(apiRequestMicroloanVerifyRequest => $apiRequestMicroloanVerifyRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MicroloanControllerApi->microloanVerify: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.MicroloanControllerApi()
apiRequestMicroloanVerifyRequest =  # ApiRequestMicroloanVerifyRequest | 

try:
    api_response = api_instance.gmicroloan_verify(apiRequestMicroloanVerifyRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MicroloanControllerApi->microloanVerify: %s\n" % e)

extern crate MicroloanControllerApi;

pub fn main() {
    let apiRequestMicroloanVerifyRequest = ; // ApiRequestMicroloanVerifyRequest

    let mut context = MicroloanControllerApi::Context::default();
    let result = client.microloanVerify(apiRequestMicroloanVerifyRequest, &context).wait();

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

Scopes

Parameters

Body

Name	Description
apiRequestMicroloanVerifyRequest *

Responses

Schema

microloanIssue

It's final API which starts loan issue process

/microloans/applications/issue

Usage Examples and SDK

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://http:/microloans/applications/issue" \
 -d '{
  "id" : "3fa85f64-5717-4562-b3fc-2c963f66afa6",
  "params" : {
    "applicationId" : "b2ff7746-050c-43d9-bd20-ba1f84710f1f",
    "clientData" : {
      "firstName" : "ANVAR",
      "fatherName" : "MAXUTDINOVICH",
      "surname" : "XODJAYEV",
      "firstNameEn" : "ANVAR",
      "surnameEn" : "XODJAYEV",
      "fatherNameEn" : "MAXUTDINOVICH",
      "personCode" : "3569965320735",
      "gender" : "1",
      "dateOfBirth" : "23.01.1996",
      "placeOfBirth" : "BUXORO SHAHRI",
      "domicileCountry" : "860",
      "domicileRegion" : "30",
      "domicileDistrict" : "6",
      "address" : "Низомий Ганжавий МФЙ, Навои кучаси, 13-уй, дом-хонадон",
      "email" : "qwerty1111@gmail.com",
      "phoneMobile" : "998901234567",
      "docSeries" : "AD",
      "docNumber" : "9012345",
      "docType" : "0",
      "docIssuedBy" : "ЯШНОБОДСКИЙ РУВД ГОРОДА ТАШКЕНТА",
      "issueDate" : "17.10.2024",
      "docValidity" : "16.10.2034",
      "passDateExp" : "16.10.2034"
    }
  }
}'

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

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

public class MicroloanControllerApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        MicroloanControllerApi apiInstance = new MicroloanControllerApi();
        ApiRequestMicroloanIssueRequest apiRequestMicroloanIssueRequest = ; // ApiRequestMicroloanIssueRequest | 

        try {
            ApiResponseMicroloanIssueResponse result = apiInstance.microloanIssue(apiRequestMicroloanIssueRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MicroloanControllerApi#microloanIssue");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ApiRequestMicroloanIssueRequest apiRequestMicroloanIssueRequest = new ApiRequestMicroloanIssueRequest(); // ApiRequestMicroloanIssueRequest | 

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

import org.openapitools.client.api.MicroloanControllerApi;

public class MicroloanControllerApiExample {
    public static void main(String[] args) {
        MicroloanControllerApi apiInstance = new MicroloanControllerApi();
        ApiRequestMicroloanIssueRequest apiRequestMicroloanIssueRequest = ; // ApiRequestMicroloanIssueRequest | 

        try {
            ApiResponseMicroloanIssueResponse result = apiInstance.microloanIssue(apiRequestMicroloanIssueRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MicroloanControllerApi#microloanIssue");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

[apiInstance microloanIssueWith:apiRequestMicroloanIssueRequest
              completionHandler: ^(ApiResponseMicroloanIssueResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BaaSProjectApis = require('baa_s_project_apis');
var defaultClient = BaaSProjectApis.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new BaaSProjectApis.MicroloanControllerApi()
var apiRequestMicroloanIssueRequest = ; // {ApiRequestMicroloanIssueRequest} 

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

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

namespace Example
{
    public class microloanIssueExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new MicroloanControllerApi();
            var apiRequestMicroloanIssueRequest = new ApiRequestMicroloanIssueRequest(); // ApiRequestMicroloanIssueRequest | 

            try {
                ApiResponseMicroloanIssueResponse result = apiInstance.microloanIssue(apiRequestMicroloanIssueRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MicroloanControllerApi.microloanIssue: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MicroloanControllerApi();
$apiRequestMicroloanIssueRequest = ; // ApiRequestMicroloanIssueRequest | 

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

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

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MicroloanControllerApi->new();
my $apiRequestMicroloanIssueRequest = WWW::OPenAPIClient::Object::ApiRequestMicroloanIssueRequest->new(); # ApiRequestMicroloanIssueRequest | 

eval {
    my $result = $api_instance->microloanIssue(apiRequestMicroloanIssueRequest => $apiRequestMicroloanIssueRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MicroloanControllerApi->microloanIssue: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.MicroloanControllerApi()
apiRequestMicroloanIssueRequest =  # ApiRequestMicroloanIssueRequest | 

try:
    api_response = api_instance.hmicroloan_issue(apiRequestMicroloanIssueRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MicroloanControllerApi->microloanIssue: %s\n" % e)

extern crate MicroloanControllerApi;

pub fn main() {
    let apiRequestMicroloanIssueRequest = ; // ApiRequestMicroloanIssueRequest

    let mut context = MicroloanControllerApi::Context::default();
    let result = client.microloanIssue(apiRequestMicroloanIssueRequest, &context).wait();

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

Scopes

Parameters

Body

Name	Description
apiRequestMicroloanIssueRequest *

Responses

Schema

microloanInfo

API for retrieving loan-info

/microloans/info

Usage Examples and SDK

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://http:/microloans/info" \
 -d '{
  "id" : "955e8473-8905-419f-baf4-0fa98e6c219d",
  "params" : {
    "applicationId" : "218fc3b1-fdae-4ac6-9dab-b40c7fe20f97"
  }
}'

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

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

public class MicroloanControllerApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        MicroloanControllerApi apiInstance = new MicroloanControllerApi();
        ApiRequestMicroloanInfoRequest apiRequestMicroloanInfoRequest = ; // ApiRequestMicroloanInfoRequest | 

        try {
            ApiResponseMicroloanInfoResponse result = apiInstance.microloanInfo(apiRequestMicroloanInfoRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MicroloanControllerApi#microloanInfo");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ApiRequestMicroloanInfoRequest apiRequestMicroloanInfoRequest = new ApiRequestMicroloanInfoRequest(); // ApiRequestMicroloanInfoRequest | 

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

import org.openapitools.client.api.MicroloanControllerApi;

public class MicroloanControllerApiExample {
    public static void main(String[] args) {
        MicroloanControllerApi apiInstance = new MicroloanControllerApi();
        ApiRequestMicroloanInfoRequest apiRequestMicroloanInfoRequest = ; // ApiRequestMicroloanInfoRequest | 

        try {
            ApiResponseMicroloanInfoResponse result = apiInstance.microloanInfo(apiRequestMicroloanInfoRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MicroloanControllerApi#microloanInfo");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

[apiInstance microloanInfoWith:apiRequestMicroloanInfoRequest
              completionHandler: ^(ApiResponseMicroloanInfoResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BaaSProjectApis = require('baa_s_project_apis');
var defaultClient = BaaSProjectApis.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new BaaSProjectApis.MicroloanControllerApi()
var apiRequestMicroloanInfoRequest = ; // {ApiRequestMicroloanInfoRequest} 

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

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

namespace Example
{
    public class microloanInfoExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new MicroloanControllerApi();
            var apiRequestMicroloanInfoRequest = new ApiRequestMicroloanInfoRequest(); // ApiRequestMicroloanInfoRequest | 

            try {
                ApiResponseMicroloanInfoResponse result = apiInstance.microloanInfo(apiRequestMicroloanInfoRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MicroloanControllerApi.microloanInfo: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MicroloanControllerApi();
$apiRequestMicroloanInfoRequest = ; // ApiRequestMicroloanInfoRequest | 

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

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

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MicroloanControllerApi->new();
my $apiRequestMicroloanInfoRequest = WWW::OPenAPIClient::Object::ApiRequestMicroloanInfoRequest->new(); # ApiRequestMicroloanInfoRequest | 

eval {
    my $result = $api_instance->microloanInfo(apiRequestMicroloanInfoRequest => $apiRequestMicroloanInfoRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MicroloanControllerApi->microloanInfo: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.MicroloanControllerApi()
apiRequestMicroloanInfoRequest =  # ApiRequestMicroloanInfoRequest | 

try:
    api_response = api_instance.imicroloan_info(apiRequestMicroloanInfoRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MicroloanControllerApi->microloanInfo: %s\n" % e)

extern crate MicroloanControllerApi;

pub fn main() {
    let apiRequestMicroloanInfoRequest = ; // ApiRequestMicroloanInfoRequest

    let mut context = MicroloanControllerApi::Context::default();
    let result = client.microloanInfo(apiRequestMicroloanInfoRequest, &context).wait();

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

Scopes

Parameters

Body

Name	Description
apiRequestMicroloanInfoRequest *

Responses

Schema

getMicroloanSchedule

/microloans/schedule

Usage Examples and SDK

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://http:/microloans/schedule" \
 -d '{
  "id" : "5db8ab9d-84b3-4b70-8033-a5c1e9761119",
  "params" : {
    "loanId" : "34433001"
  }
}'

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

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

public class MicroloanControllerApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        MicroloanControllerApi apiInstance = new MicroloanControllerApi();
        ApiRequestMicroloanScheduleRequest apiRequestMicroloanScheduleRequest = ; // ApiRequestMicroloanScheduleRequest | 

        try {
            ApiResponseMicroloanScheduleResponse result = apiInstance.getMicroloanSchedule(apiRequestMicroloanScheduleRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MicroloanControllerApi#getMicroloanSchedule");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ApiRequestMicroloanScheduleRequest apiRequestMicroloanScheduleRequest = new ApiRequestMicroloanScheduleRequest(); // ApiRequestMicroloanScheduleRequest | 

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

import org.openapitools.client.api.MicroloanControllerApi;

public class MicroloanControllerApiExample {
    public static void main(String[] args) {
        MicroloanControllerApi apiInstance = new MicroloanControllerApi();
        ApiRequestMicroloanScheduleRequest apiRequestMicroloanScheduleRequest = ; // ApiRequestMicroloanScheduleRequest | 

        try {
            ApiResponseMicroloanScheduleResponse result = apiInstance.getMicroloanSchedule(apiRequestMicroloanScheduleRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MicroloanControllerApi#getMicroloanSchedule");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

[apiInstance getMicroloanScheduleWith:apiRequestMicroloanScheduleRequest
              completionHandler: ^(ApiResponseMicroloanScheduleResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BaaSProjectApis = require('baa_s_project_apis');
var defaultClient = BaaSProjectApis.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new BaaSProjectApis.MicroloanControllerApi()
var apiRequestMicroloanScheduleRequest = ; // {ApiRequestMicroloanScheduleRequest} 

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

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

namespace Example
{
    public class getMicroloanScheduleExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new MicroloanControllerApi();
            var apiRequestMicroloanScheduleRequest = new ApiRequestMicroloanScheduleRequest(); // ApiRequestMicroloanScheduleRequest | 

            try {
                ApiResponseMicroloanScheduleResponse result = apiInstance.getMicroloanSchedule(apiRequestMicroloanScheduleRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MicroloanControllerApi.getMicroloanSchedule: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MicroloanControllerApi();
$apiRequestMicroloanScheduleRequest = ; // ApiRequestMicroloanScheduleRequest | 

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

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

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MicroloanControllerApi->new();
my $apiRequestMicroloanScheduleRequest = WWW::OPenAPIClient::Object::ApiRequestMicroloanScheduleRequest->new(); # ApiRequestMicroloanScheduleRequest | 

eval {
    my $result = $api_instance->getMicroloanSchedule(apiRequestMicroloanScheduleRequest => $apiRequestMicroloanScheduleRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MicroloanControllerApi->getMicroloanSchedule: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.MicroloanControllerApi()
apiRequestMicroloanScheduleRequest =  # ApiRequestMicroloanScheduleRequest | 

try:
    api_response = api_instance.jget_microloan_schedule(apiRequestMicroloanScheduleRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MicroloanControllerApi->getMicroloanSchedule: %s\n" % e)

extern crate MicroloanControllerApi;

pub fn main() {
    let apiRequestMicroloanScheduleRequest = ; // ApiRequestMicroloanScheduleRequest

    let mut context = MicroloanControllerApi::Context::default();
    let result = client.getMicroloanSchedule(apiRequestMicroloanScheduleRequest, &context).wait();

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

Scopes

Parameters

Body

Name	Description
apiRequestMicroloanScheduleRequest *

Responses

Schema

getLoanPaymentHistory

/microloans/payments

Usage Examples and SDK

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://http:/microloans/payments" \
 -d '{
  "id" : "93d1710c-9d51-42a3-a247-39ada446d7b2",
  "params" : {
    "loanId" : "3444201"
  }
}'

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

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

public class MicroloanControllerApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        MicroloanControllerApi apiInstance = new MicroloanControllerApi();
        ApiRequestLoanPaymentHistoryRequest apiRequestLoanPaymentHistoryRequest = ; // ApiRequestLoanPaymentHistoryRequest | 

        try {
            ApiResponseLoanPaymentHistoryResponse result = apiInstance.getLoanPaymentHistory(apiRequestLoanPaymentHistoryRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MicroloanControllerApi#getLoanPaymentHistory");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ApiRequestLoanPaymentHistoryRequest apiRequestLoanPaymentHistoryRequest = new ApiRequestLoanPaymentHistoryRequest(); // ApiRequestLoanPaymentHistoryRequest | 

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

import org.openapitools.client.api.MicroloanControllerApi;

public class MicroloanControllerApiExample {
    public static void main(String[] args) {
        MicroloanControllerApi apiInstance = new MicroloanControllerApi();
        ApiRequestLoanPaymentHistoryRequest apiRequestLoanPaymentHistoryRequest = ; // ApiRequestLoanPaymentHistoryRequest | 

        try {
            ApiResponseLoanPaymentHistoryResponse result = apiInstance.getLoanPaymentHistory(apiRequestLoanPaymentHistoryRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MicroloanControllerApi#getLoanPaymentHistory");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

[apiInstance getLoanPaymentHistoryWith:apiRequestLoanPaymentHistoryRequest
              completionHandler: ^(ApiResponseLoanPaymentHistoryResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BaaSProjectApis = require('baa_s_project_apis');
var defaultClient = BaaSProjectApis.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new BaaSProjectApis.MicroloanControllerApi()
var apiRequestLoanPaymentHistoryRequest = ; // {ApiRequestLoanPaymentHistoryRequest} 

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

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

namespace Example
{
    public class getLoanPaymentHistoryExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new MicroloanControllerApi();
            var apiRequestLoanPaymentHistoryRequest = new ApiRequestLoanPaymentHistoryRequest(); // ApiRequestLoanPaymentHistoryRequest | 

            try {
                ApiResponseLoanPaymentHistoryResponse result = apiInstance.getLoanPaymentHistory(apiRequestLoanPaymentHistoryRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MicroloanControllerApi.getLoanPaymentHistory: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MicroloanControllerApi();
$apiRequestLoanPaymentHistoryRequest = ; // ApiRequestLoanPaymentHistoryRequest | 

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

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

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MicroloanControllerApi->new();
my $apiRequestLoanPaymentHistoryRequest = WWW::OPenAPIClient::Object::ApiRequestLoanPaymentHistoryRequest->new(); # ApiRequestLoanPaymentHistoryRequest | 

eval {
    my $result = $api_instance->getLoanPaymentHistory(apiRequestLoanPaymentHistoryRequest => $apiRequestLoanPaymentHistoryRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MicroloanControllerApi->getLoanPaymentHistory: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.MicroloanControllerApi()
apiRequestLoanPaymentHistoryRequest =  # ApiRequestLoanPaymentHistoryRequest | 

try:
    api_response = api_instance.kget_loan_payment_history(apiRequestLoanPaymentHistoryRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MicroloanControllerApi->getLoanPaymentHistory: %s\n" % e)

extern crate MicroloanControllerApi;

pub fn main() {
    let apiRequestLoanPaymentHistoryRequest = ; // ApiRequestLoanPaymentHistoryRequest

    let mut context = MicroloanControllerApi::Context::default();
    let result = client.getLoanPaymentHistory(apiRequestLoanPaymentHistoryRequest, &context).wait();

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

Scopes

Parameters

Body

Name	Description
apiRequestLoanPaymentHistoryRequest *

Responses

Schema

RepaymentController

loanRepaymentCheck

/repayment/loans/check

Usage Examples and SDK

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://http:/repayment/loans/check" \
 -d '{
  "id" : "b2b75069-73f3-4b95-b5c2-218b99d9524f",
  "params" : {
    "loanId" : 323132
  }
}'

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

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

public class RepaymentControllerApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RepaymentControllerApi apiInstance = new RepaymentControllerApi();
        ApiRequestLoanRepaymentCheckRequest apiRequestLoanRepaymentCheckRequest = ; // ApiRequestLoanRepaymentCheckRequest | 

        try {
            ApiResponseLoanRepaymentCheckResponse result = apiInstance.loanRepaymentCheck(apiRequestLoanRepaymentCheckRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RepaymentControllerApi#loanRepaymentCheck");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ApiRequestLoanRepaymentCheckRequest apiRequestLoanRepaymentCheckRequest = new ApiRequestLoanRepaymentCheckRequest(); // ApiRequestLoanRepaymentCheckRequest | 

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

import org.openapitools.client.api.RepaymentControllerApi;

public class RepaymentControllerApiExample {
    public static void main(String[] args) {
        RepaymentControllerApi apiInstance = new RepaymentControllerApi();
        ApiRequestLoanRepaymentCheckRequest apiRequestLoanRepaymentCheckRequest = ; // ApiRequestLoanRepaymentCheckRequest | 

        try {
            ApiResponseLoanRepaymentCheckResponse result = apiInstance.loanRepaymentCheck(apiRequestLoanRepaymentCheckRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RepaymentControllerApi#loanRepaymentCheck");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

[apiInstance loanRepaymentCheckWith:apiRequestLoanRepaymentCheckRequest
              completionHandler: ^(ApiResponseLoanRepaymentCheckResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BaaSProjectApis = require('baa_s_project_apis');
var defaultClient = BaaSProjectApis.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new BaaSProjectApis.RepaymentControllerApi()
var apiRequestLoanRepaymentCheckRequest = ; // {ApiRequestLoanRepaymentCheckRequest} 

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

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

namespace Example
{
    public class loanRepaymentCheckExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RepaymentControllerApi();
            var apiRequestLoanRepaymentCheckRequest = new ApiRequestLoanRepaymentCheckRequest(); // ApiRequestLoanRepaymentCheckRequest | 

            try {
                ApiResponseLoanRepaymentCheckResponse result = apiInstance.loanRepaymentCheck(apiRequestLoanRepaymentCheckRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RepaymentControllerApi.loanRepaymentCheck: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RepaymentControllerApi();
$apiRequestLoanRepaymentCheckRequest = ; // ApiRequestLoanRepaymentCheckRequest | 

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

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

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RepaymentControllerApi->new();
my $apiRequestLoanRepaymentCheckRequest = WWW::OPenAPIClient::Object::ApiRequestLoanRepaymentCheckRequest->new(); # ApiRequestLoanRepaymentCheckRequest | 

eval {
    my $result = $api_instance->loanRepaymentCheck(apiRequestLoanRepaymentCheckRequest => $apiRequestLoanRepaymentCheckRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RepaymentControllerApi->loanRepaymentCheck: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RepaymentControllerApi()
apiRequestLoanRepaymentCheckRequest =  # ApiRequestLoanRepaymentCheckRequest | 

try:
    api_response = api_instance.aloan_repayment_check(apiRequestLoanRepaymentCheckRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RepaymentControllerApi->loanRepaymentCheck: %s\n" % e)

extern crate RepaymentControllerApi;

pub fn main() {
    let apiRequestLoanRepaymentCheckRequest = ; // ApiRequestLoanRepaymentCheckRequest

    let mut context = RepaymentControllerApi::Context::default();
    let result = client.loanRepaymentCheck(apiRequestLoanRepaymentCheckRequest, &context).wait();

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

Scopes

Parameters

Body

Name	Description
apiRequestLoanRepaymentCheckRequest *

Responses

Schema

loanRepaymentPay

/repayment/loans/pay

Usage Examples and SDK

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://http:/repayment/loans/pay" \
 -d '{
  "id" : "b2b75069-73f3-4b95-b5c2-218b99d9524f",
  "params" : {
    "loanId" : "32313",
    "paymentType" : "EARLY",
    "requestId" : "c9d26a64-37cd-4383-bba1-f835573bd0e6",
    "debitId" : "3232314142432",
    "amount" : 1000000000,
    "processingType" : "UZCARD"
  }
}'

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

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

public class RepaymentControllerApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RepaymentControllerApi apiInstance = new RepaymentControllerApi();
        ApiRequestLoanRepaymentPayRequest apiRequestLoanRepaymentPayRequest = ; // ApiRequestLoanRepaymentPayRequest | 

        try {
            ApiResponseLoanRepaymentPayResponse result = apiInstance.loanRepaymentPay(apiRequestLoanRepaymentPayRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RepaymentControllerApi#loanRepaymentPay");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ApiRequestLoanRepaymentPayRequest apiRequestLoanRepaymentPayRequest = new ApiRequestLoanRepaymentPayRequest(); // ApiRequestLoanRepaymentPayRequest | 

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

import org.openapitools.client.api.RepaymentControllerApi;

public class RepaymentControllerApiExample {
    public static void main(String[] args) {
        RepaymentControllerApi apiInstance = new RepaymentControllerApi();
        ApiRequestLoanRepaymentPayRequest apiRequestLoanRepaymentPayRequest = ; // ApiRequestLoanRepaymentPayRequest | 

        try {
            ApiResponseLoanRepaymentPayResponse result = apiInstance.loanRepaymentPay(apiRequestLoanRepaymentPayRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RepaymentControllerApi#loanRepaymentPay");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

[apiInstance loanRepaymentPayWith:apiRequestLoanRepaymentPayRequest
              completionHandler: ^(ApiResponseLoanRepaymentPayResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BaaSProjectApis = require('baa_s_project_apis');
var defaultClient = BaaSProjectApis.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new BaaSProjectApis.RepaymentControllerApi()
var apiRequestLoanRepaymentPayRequest = ; // {ApiRequestLoanRepaymentPayRequest} 

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

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

namespace Example
{
    public class loanRepaymentPayExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RepaymentControllerApi();
            var apiRequestLoanRepaymentPayRequest = new ApiRequestLoanRepaymentPayRequest(); // ApiRequestLoanRepaymentPayRequest | 

            try {
                ApiResponseLoanRepaymentPayResponse result = apiInstance.loanRepaymentPay(apiRequestLoanRepaymentPayRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RepaymentControllerApi.loanRepaymentPay: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RepaymentControllerApi();
$apiRequestLoanRepaymentPayRequest = ; // ApiRequestLoanRepaymentPayRequest | 

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

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

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RepaymentControllerApi->new();
my $apiRequestLoanRepaymentPayRequest = WWW::OPenAPIClient::Object::ApiRequestLoanRepaymentPayRequest->new(); # ApiRequestLoanRepaymentPayRequest | 

eval {
    my $result = $api_instance->loanRepaymentPay(apiRequestLoanRepaymentPayRequest => $apiRequestLoanRepaymentPayRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RepaymentControllerApi->loanRepaymentPay: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RepaymentControllerApi()
apiRequestLoanRepaymentPayRequest =  # ApiRequestLoanRepaymentPayRequest | 

try:
    api_response = api_instance.bloan_repayment_pay(apiRequestLoanRepaymentPayRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RepaymentControllerApi->loanRepaymentPay: %s\n" % e)

extern crate RepaymentControllerApi;

pub fn main() {
    let apiRequestLoanRepaymentPayRequest = ; // ApiRequestLoanRepaymentPayRequest

    let mut context = RepaymentControllerApi::Context::default();
    let result = client.loanRepaymentPay(apiRequestLoanRepaymentPayRequest, &context).wait();

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

Scopes

Parameters

Body

Name	Description
apiRequestLoanRepaymentPayRequest *

Responses

Schema

loanRepaymentStatus

/repayment/loans/status

Usage Examples and SDK

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://http:/repayment/loans/status" \
 -d '{
  "id" : "b2b75069-73f3-4b95-b5c2-218b99d9524f",
  "params" : {
    "requestId" : "1001976902"
  }
}'

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

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

public class RepaymentControllerApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        RepaymentControllerApi apiInstance = new RepaymentControllerApi();
        ApiRequestLoanRepaymentStatusRequest apiRequestLoanRepaymentStatusRequest = ; // ApiRequestLoanRepaymentStatusRequest | 

        try {
            ApiRequestLoanRepaymentStatusResponse result = apiInstance.loanRepaymentStatus(apiRequestLoanRepaymentStatusRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RepaymentControllerApi#loanRepaymentStatus");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ApiRequestLoanRepaymentStatusRequest apiRequestLoanRepaymentStatusRequest = new ApiRequestLoanRepaymentStatusRequest(); // ApiRequestLoanRepaymentStatusRequest | 

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

import org.openapitools.client.api.RepaymentControllerApi;

public class RepaymentControllerApiExample {
    public static void main(String[] args) {
        RepaymentControllerApi apiInstance = new RepaymentControllerApi();
        ApiRequestLoanRepaymentStatusRequest apiRequestLoanRepaymentStatusRequest = ; // ApiRequestLoanRepaymentStatusRequest | 

        try {
            ApiRequestLoanRepaymentStatusResponse result = apiInstance.loanRepaymentStatus(apiRequestLoanRepaymentStatusRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RepaymentControllerApi#loanRepaymentStatus");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

[apiInstance loanRepaymentStatusWith:apiRequestLoanRepaymentStatusRequest
              completionHandler: ^(ApiRequestLoanRepaymentStatusResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BaaSProjectApis = require('baa_s_project_apis');
var defaultClient = BaaSProjectApis.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new BaaSProjectApis.RepaymentControllerApi()
var apiRequestLoanRepaymentStatusRequest = ; // {ApiRequestLoanRepaymentStatusRequest} 

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

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

namespace Example
{
    public class loanRepaymentStatusExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new RepaymentControllerApi();
            var apiRequestLoanRepaymentStatusRequest = new ApiRequestLoanRepaymentStatusRequest(); // ApiRequestLoanRepaymentStatusRequest | 

            try {
                ApiRequestLoanRepaymentStatusResponse result = apiInstance.loanRepaymentStatus(apiRequestLoanRepaymentStatusRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RepaymentControllerApi.loanRepaymentStatus: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RepaymentControllerApi();
$apiRequestLoanRepaymentStatusRequest = ; // ApiRequestLoanRepaymentStatusRequest | 

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

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

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RepaymentControllerApi->new();
my $apiRequestLoanRepaymentStatusRequest = WWW::OPenAPIClient::Object::ApiRequestLoanRepaymentStatusRequest->new(); # ApiRequestLoanRepaymentStatusRequest | 

eval {
    my $result = $api_instance->loanRepaymentStatus(apiRequestLoanRepaymentStatusRequest => $apiRequestLoanRepaymentStatusRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RepaymentControllerApi->loanRepaymentStatus: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.RepaymentControllerApi()
apiRequestLoanRepaymentStatusRequest =  # ApiRequestLoanRepaymentStatusRequest | 

try:
    api_response = api_instance.cloan_repayment_status(apiRequestLoanRepaymentStatusRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RepaymentControllerApi->loanRepaymentStatus: %s\n" % e)

extern crate RepaymentControllerApi;

pub fn main() {
    let apiRequestLoanRepaymentStatusRequest = ; // ApiRequestLoanRepaymentStatusRequest

    let mut context = RepaymentControllerApi::Context::default();
    let result = client.loanRepaymentStatus(apiRequestLoanRepaymentStatusRequest, &context).wait();

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

Scopes

Parameters

Body

Name	Description
apiRequestLoanRepaymentStatusRequest *

Responses

Schema

TransferController

createAccountToCardTransfer

/transfers/account-to-card/create

Usage Examples and SDK

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://http:/transfers/account-to-card/create" \
 -d '{
  "id" : "78a6297a-3261-4c7d-af64-5941d680a7e5",
  "params" : {
    "applicationId" : "bf9bc1c5-316a-4994-a5c1-3faa72834363",
    "externalId" : "78a6297a-3261-4c7d-af64-5941d680a7e5",
    "pan" : "8600010103030909",
    "cardHolderName" : "Ravshanov Azizbek",
    "amount" : 100000000,
    "receiverCardType" : "UZCARD"
  }
}'

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

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

public class TransferControllerApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        TransferControllerApi apiInstance = new TransferControllerApi();
        ApiRequestTransferAccountToCardRequest apiRequestTransferAccountToCardRequest = ; // ApiRequestTransferAccountToCardRequest | 

        try {
            ApiResponseTransferCreateResponse result = apiInstance.createAccountToCardTransfer(apiRequestTransferAccountToCardRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransferControllerApi#createAccountToCardTransfer");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ApiRequestTransferAccountToCardRequest apiRequestTransferAccountToCardRequest = new ApiRequestTransferAccountToCardRequest(); // ApiRequestTransferAccountToCardRequest | 

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

import org.openapitools.client.api.TransferControllerApi;

public class TransferControllerApiExample {
    public static void main(String[] args) {
        TransferControllerApi apiInstance = new TransferControllerApi();
        ApiRequestTransferAccountToCardRequest apiRequestTransferAccountToCardRequest = ; // ApiRequestTransferAccountToCardRequest | 

        try {
            ApiResponseTransferCreateResponse result = apiInstance.createAccountToCardTransfer(apiRequestTransferAccountToCardRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransferControllerApi#createAccountToCardTransfer");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

[apiInstance createAccountToCardTransferWith:apiRequestTransferAccountToCardRequest
              completionHandler: ^(ApiResponseTransferCreateResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BaaSProjectApis = require('baa_s_project_apis');
var defaultClient = BaaSProjectApis.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new BaaSProjectApis.TransferControllerApi()
var apiRequestTransferAccountToCardRequest = ; // {ApiRequestTransferAccountToCardRequest} 

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

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

namespace Example
{
    public class createAccountToCardTransferExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new TransferControllerApi();
            var apiRequestTransferAccountToCardRequest = new ApiRequestTransferAccountToCardRequest(); // ApiRequestTransferAccountToCardRequest | 

            try {
                ApiResponseTransferCreateResponse result = apiInstance.createAccountToCardTransfer(apiRequestTransferAccountToCardRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TransferControllerApi.createAccountToCardTransfer: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TransferControllerApi();
$apiRequestTransferAccountToCardRequest = ; // ApiRequestTransferAccountToCardRequest | 

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

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

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TransferControllerApi->new();
my $apiRequestTransferAccountToCardRequest = WWW::OPenAPIClient::Object::ApiRequestTransferAccountToCardRequest->new(); # ApiRequestTransferAccountToCardRequest | 

eval {
    my $result = $api_instance->createAccountToCardTransfer(apiRequestTransferAccountToCardRequest => $apiRequestTransferAccountToCardRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TransferControllerApi->createAccountToCardTransfer: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.TransferControllerApi()
apiRequestTransferAccountToCardRequest =  # ApiRequestTransferAccountToCardRequest | 

try:
    api_response = api_instance.acreate_account_to_card_transfer(apiRequestTransferAccountToCardRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TransferControllerApi->createAccountToCardTransfer: %s\n" % e)

extern crate TransferControllerApi;

pub fn main() {
    let apiRequestTransferAccountToCardRequest = ; // ApiRequestTransferAccountToCardRequest

    let mut context = TransferControllerApi::Context::default();
    let result = client.createAccountToCardTransfer(apiRequestTransferAccountToCardRequest, &context).wait();

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

Scopes

Parameters

Body

Name	Description
apiRequestTransferAccountToCardRequest *

Responses

Schema

confirmAccountToCardTransfer

/transfers/account-to-card/confirm

Usage Examples and SDK

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://http:/transfers/account-to-card/confirm" \
 -d '{
  "id" : "523f8deb-6d56-4d56-b227-59be3828ebfc",
  "params" : {
    "externalId" : "523f8deb-6d56-4d56-b227-59be3828ebfc",
    "transactionId" : "32323994400"
  }
}'

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

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

public class TransferControllerApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        TransferControllerApi apiInstance = new TransferControllerApi();
        ApiRequestTransferConfirmRequest apiRequestTransferConfirmRequest = ; // ApiRequestTransferConfirmRequest | 

        try {
            ApiResponseTransferConfirmResponse result = apiInstance.confirmAccountToCardTransfer(apiRequestTransferConfirmRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransferControllerApi#confirmAccountToCardTransfer");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ApiRequestTransferConfirmRequest apiRequestTransferConfirmRequest = new ApiRequestTransferConfirmRequest(); // ApiRequestTransferConfirmRequest | 

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

import org.openapitools.client.api.TransferControllerApi;

public class TransferControllerApiExample {
    public static void main(String[] args) {
        TransferControllerApi apiInstance = new TransferControllerApi();
        ApiRequestTransferConfirmRequest apiRequestTransferConfirmRequest = ; // ApiRequestTransferConfirmRequest | 

        try {
            ApiResponseTransferConfirmResponse result = apiInstance.confirmAccountToCardTransfer(apiRequestTransferConfirmRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransferControllerApi#confirmAccountToCardTransfer");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

[apiInstance confirmAccountToCardTransferWith:apiRequestTransferConfirmRequest
              completionHandler: ^(ApiResponseTransferConfirmResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BaaSProjectApis = require('baa_s_project_apis');
var defaultClient = BaaSProjectApis.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new BaaSProjectApis.TransferControllerApi()
var apiRequestTransferConfirmRequest = ; // {ApiRequestTransferConfirmRequest} 

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

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

namespace Example
{
    public class confirmAccountToCardTransferExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new TransferControllerApi();
            var apiRequestTransferConfirmRequest = new ApiRequestTransferConfirmRequest(); // ApiRequestTransferConfirmRequest | 

            try {
                ApiResponseTransferConfirmResponse result = apiInstance.confirmAccountToCardTransfer(apiRequestTransferConfirmRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TransferControllerApi.confirmAccountToCardTransfer: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TransferControllerApi();
$apiRequestTransferConfirmRequest = ; // ApiRequestTransferConfirmRequest | 

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

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

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TransferControllerApi->new();
my $apiRequestTransferConfirmRequest = WWW::OPenAPIClient::Object::ApiRequestTransferConfirmRequest->new(); # ApiRequestTransferConfirmRequest | 

eval {
    my $result = $api_instance->confirmAccountToCardTransfer(apiRequestTransferConfirmRequest => $apiRequestTransferConfirmRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TransferControllerApi->confirmAccountToCardTransfer: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.TransferControllerApi()
apiRequestTransferConfirmRequest =  # ApiRequestTransferConfirmRequest | 

try:
    api_response = api_instance.bconfirm_account_to_card_transfer(apiRequestTransferConfirmRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TransferControllerApi->confirmAccountToCardTransfer: %s\n" % e)

extern crate TransferControllerApi;

pub fn main() {
    let apiRequestTransferConfirmRequest = ; // ApiRequestTransferConfirmRequest

    let mut context = TransferControllerApi::Context::default();
    let result = client.confirmAccountToCardTransfer(apiRequestTransferConfirmRequest, &context).wait();

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

Scopes

Parameters

Body

Name	Description
apiRequestTransferConfirmRequest *

Responses

Schema

checkTransferStatus

/transfers/check-status

Usage Examples and SDK

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://http:/transfers/check-status" \
 -d '{
  "id" : "d6961c07-58fd-42a9-b9fa-50af48a2cda3",
  "params" : {
    "externalId" : "d6961c07-58fd-42a9-b9fa-50af48a2cda3",
    "transactionId" : "3444921"
  }
}'

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

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

public class TransferControllerApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: BearerAuth
        HttpBearerAuth BearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("BearerAuth");
        BearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        TransferControllerApi apiInstance = new TransferControllerApi();
        ApiRequestTransferStatusCheckRequest apiRequestTransferStatusCheckRequest = ; // ApiRequestTransferStatusCheckRequest | 

        try {
            ApiResponseTransferStatusCheckResponse result = apiInstance.checkTransferStatus(apiRequestTransferStatusCheckRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransferControllerApi#checkTransferStatus");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ApiRequestTransferStatusCheckRequest apiRequestTransferStatusCheckRequest = new ApiRequestTransferStatusCheckRequest(); // ApiRequestTransferStatusCheckRequest | 

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

import org.openapitools.client.api.TransferControllerApi;

public class TransferControllerApiExample {
    public static void main(String[] args) {
        TransferControllerApi apiInstance = new TransferControllerApi();
        ApiRequestTransferStatusCheckRequest apiRequestTransferStatusCheckRequest = ; // ApiRequestTransferStatusCheckRequest | 

        try {
            ApiResponseTransferStatusCheckResponse result = apiInstance.checkTransferStatus(apiRequestTransferStatusCheckRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransferControllerApi#checkTransferStatus");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: BearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

[apiInstance checkTransferStatusWith:apiRequestTransferStatusCheckRequest
              completionHandler: ^(ApiResponseTransferStatusCheckResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BaaSProjectApis = require('baa_s_project_apis');
var defaultClient = BaaSProjectApis.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: BearerAuth
var BearerAuth = defaultClient.authentications['BearerAuth'];
BearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new BaaSProjectApis.TransferControllerApi()
var apiRequestTransferStatusCheckRequest = ; // {ApiRequestTransferStatusCheckRequest} 

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

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

namespace Example
{
    public class checkTransferStatusExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: BearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new TransferControllerApi();
            var apiRequestTransferStatusCheckRequest = new ApiRequestTransferStatusCheckRequest(); // ApiRequestTransferStatusCheckRequest | 

            try {
                ApiResponseTransferStatusCheckResponse result = apiInstance.checkTransferStatus(apiRequestTransferStatusCheckRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TransferControllerApi.checkTransferStatus: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: BearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TransferControllerApi();
$apiRequestTransferStatusCheckRequest = ; // ApiRequestTransferStatusCheckRequest | 

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

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

# Configure Bearer (JWT) access token for authorization: BearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TransferControllerApi->new();
my $apiRequestTransferStatusCheckRequest = WWW::OPenAPIClient::Object::ApiRequestTransferStatusCheckRequest->new(); # ApiRequestTransferStatusCheckRequest | 

eval {
    my $result = $api_instance->checkTransferStatus(apiRequestTransferStatusCheckRequest => $apiRequestTransferStatusCheckRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TransferControllerApi->checkTransferStatus: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: BearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.TransferControllerApi()
apiRequestTransferStatusCheckRequest =  # ApiRequestTransferStatusCheckRequest | 

try:
    api_response = api_instance.ccheck_transfer_status(apiRequestTransferStatusCheckRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TransferControllerApi->checkTransferStatus: %s\n" % e)

extern crate TransferControllerApi;

pub fn main() {
    let apiRequestTransferStatusCheckRequest = ; // ApiRequestTransferStatusCheckRequest

    let mut context = TransferControllerApi::Context::default();
    let result = client.checkTransferStatus(apiRequestTransferStatusCheckRequest, &context).wait();

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

Scopes

Parameters

Body

Name	Description
apiRequestTransferStatusCheckRequest *

Responses

Schema

BaaS project APIs

API and SDK Documentation

Authorization

jwtToken

Usage Examples and SDK

Scopes

Parameters

Responses

CardController

cardsByPinfl

Usage Examples and SDK

Scopes

Parameters

Responses

attachCard

Usage Examples and SDK

Scopes

Parameters

Responses

verifyCard

Usage Examples and SDK

Scopes

Parameters

Responses

CardOrder

registerOrderCardApplication

Usage Examples and SDK

Scopes

Parameters

Responses

orderCardApplicationInfo

Usage Examples and SDK

Scopes

Parameters

Responses

updateCardStatus

Usage Examples and SDK

Scopes

Parameters

Responses

cardStatusInfo

Usage Examples and SDK

Scopes

Parameters

Responses

MicroloanController

registerMicroloanApplication

Usage Examples and SDK

Scopes

Parameters

Responses

microloanApplicationInfo

Usage Examples and SDK

Scopes

Parameters

Responses

microloanCancel

Usage Examples and SDK

Scopes

Parameters

Responses

microloanVerify

Usage Examples and SDK

Scopes

Parameters

Responses

microloanIssue

Usage Examples and SDK

Scopes

Parameters

Responses

microloanInfo

Usage Examples and SDK

Scopes

Parameters

Responses

getMicroloanSchedule

Usage Examples and SDK

Scopes

Parameters