curl --include \
     --request POST \
     --header "Content-Type: application/json" \
     --data-binary "    {
        \"username\":\"johndoe1\",
        \"user_email\":\"johndoe1@awesome.com\",
        \"user_phone\":\"518-481-1001\",
        \"user_first_name\":\"John\",
        \"user_last_name\":\"Doe\",
        \"country\":\"US\",
        \"password\":\"pass\",
        \"account_name\":\"The Awesome Company\"
    }" \
'https://rest.clicksend.com/v3/account'

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

// Configure HTTP basic authorization: BasicAuth
$config = ClickSend\Configuration::getDefaultConfiguration()
              ->setUsername('USERNAME')
              ->setPassword('API_KEY');

$apiInstance = new ClickSend\Api\AccountApi(new GuzzleHttp\Client(),$config);
$account = new \ClickSend\Model\Account(); // \ClickSend\Model\Account | Account model
$account->setUserName("johndoe");
$account->setPassword("pass");
$account->setUserPhone("533-481-1041");
$account->setUserEmail("johndoesdfds1@awesome.com");
$account->setUserFirstName("John");
$account->setUserLastName("Doe");
$account->setAccountName("The Awesome Company");
$account->setCountry("US");

try {
    $result = $apiInstance->accountPost($account);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AccountApi->accountPost: ', $e->getMessage(), PHP_EOL;
}
?>

using IO.ClickSend.ClickSend.Api;
using IO.ClickSend.Client;
using IO.ClickSend.ClickSend.Model;

var accountApi = new AccountApi(Configuration.Default);
var account = new Account(
    username: "username",
    password: "password",
    userPhone: "+1231231234",
    userEmail: "johndoe@company.com",
    userFirstName: "John",
    userLastName: "Doe",
    accountName: "Your_Account_Name",
    country: "CA"
);
var response = accountApi.AccountPost(account);

var api = require('./api.js');

var accountApi = new api.AccountApi("USERNAME", "API_KEY");

var account = new api.Account();

account.username = "username";
account.password = "pass";
account.userPhone = "xxx-xxx-xxxx";
account.userEmail = "xxx@gmail.com";
account.userFirstName = "test";
account.userLastName = "test";
account.accountName = "testing";
account.country = "country";

accountApi.accountPost(account).then(function(response) {
  console.log(response.body);
}).catch(function(err){
  console.error(err.body);
});

# load the gem
require 'clicksend_client'
require 'json'

# setup authorization
ClickSendClient.configure do |config|
  # Configure HTTP basic authorization: BasicAuth
  config.username = 'USERNAME'
  config.password = 'API_KEY'
end

api_instance = ClickSendClient::AccountApi.new

# Account | Account model
account = ClickSendClient::Account.new(
  "country": "country",
  "password": "password",
  "user_email": "user_email",
  "user_first_name": "user_first_name",
  "user_last_name": "user_last_name",
  "account_name": "account_name",
  "user_phone": "user_phone",
  "username": "username"
)

begin
  # Create a new account
  result = api_instance.account_post(account)
  p JSON.parse(result)
rescue ClickSendClient::ApiError => e
  puts "Exception when calling AccountApi->account_post: #{e.response_body}"
end

from __future__ import print_function
import clicksend_client
from clicksend_client.rest import ApiException

# Configure HTTP basic authorization: BasicAuth
configuration = clicksend_client.Configuration()
configuration.username = 'USERNAME'
configuration.password = 'API_KEY'

# create an instance of the API class
api_instance = clicksend_client.AccountApi(clicksend_client.ApiClient(configuration))
account = clicksend_client.Account(
          username="username",
          user_email="xxx@gmail.com",
          user_phone="xxx-xxx-xxxx",
          user_first_name="John",
          user_last_name="Doe",
          country="US",
          password="pass",
          account_name="The Awesome Company") # Account | Account model

try:
    # Create a new account
    api_response = api_instance.account_post(account)
    print(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->account_post: %s\n" % e)

use WWW::ClickSendClient::AccountApi;
use WWW::ClickSendClient::Object::Account;

my $username = 'YOUR_API_USER_NAME';
my $password = 'YOUR_API_PASSWORD';

my $api = WWW::ClickSendClient::AccountApi->new(username => $username, password => $password);

my %params = (
    'username'        => 'test_username',
    'password'        => 'Test-password@123',
    'user_phone'      => '111-111-11111',
    'user_email'      => 'test1@test.com',
    'user_first_name' => 'user_first_name',
    'user_last_name'  => 'user_last_name',
    'account_name'    => 'account_name',
    'country'         => 'US'
);

my $acc_obj = WWW::ClickSendClient::Object::Account->new(%params);
my $json_output = $api->account_post('account' => $acc_obj);

print $json_output;

#import "CSDefaultConfiguration.h"
#import "CSAccountApi.h"

CSDefaultConfiguration *apiConfig = [CSDefaultConfiguration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: BasicAuth)
[apiConfig setUsername:@"USERNAME"];
[apiConfig setPassword:@"PASSWORD"];

CSAccountApi *accountAPI = [[CSAccountApi alloc] init];

CSAccount *account =  [[CSAccount alloc] init];
account.username = @"johndoe1";
account.password = @"password";
account.userPhone = @"518-481-1001";
account.userEmail = @"johndoe1@awesome.com";
account.userFirstName = @"John";
account.userLastName = @"Doe";
account.accountName = @"Awesome company name";
account.country = @"country";

[accountAPI accountPostWithAccount:account completionHandler:^(NSString *output, NSError *error) {
    if (error) {
        NSLog(@"Error: %@", error);
    } else {
        NSLog(@"Output: %@", output);
    }
}];

import Alamofire

if let authHeader = Request.authorizationHeader(user: "USERNAME", password: "PASSWORD") {
    ClickSendClientAPI.customHeaders = [authHeader.key : authHeader.value]
}

let account = Account(
    username: "johndoe1", 
    password: "password", 
    userPhone: "518-481-1001", 
    userEmail: "johndoe1@awesome.com", 
    userFirstName: "John", 
    userLastName: "Doe", 
    accountName: "The Awesome Company", 
    country: "userCountry"
)

AccountAPI.accountPost(account: account) { (dataString, error) in
    guard let dataString = dataString else {
        print(error!)
        return
    }

    if let data = dataString.data(using: String.Encoding.utf8) {
        do {
            if let dictonary = try (JSONSerialization.jsonObject(with: data, options: []) as? NSDictionary) {
                print(dictonary)
            } else {
                print("Cannot convert the String value to JSON")
            }
        } catch let error as NSError {
            print(error)
        }
    }
}

    Coming Soon

package ClickSend;

import ClickSend.Api.AccountApi;
import ClickSend.Model.Account;

public class create_account {
  public static void main(String[] args) {
    ApiClient defaultClient = new ApiClient();
    defaultClient.setUsername("USERNAME");
    defaultClient.setPassword("API_KEY");
    AccountApi apiInstance = new AccountApi(defaultClient);
    Account account = new Account(); // Account | Account model
    account.accountName("account Name");
    account.username("username");
    account.password("pwd");
    account.country("country");
    account.userEmail("xxx@gmail.com");
    account.userPhone("000-000-0000");
    account.userFirstName("firstname");
    account.userLastName("lastname");
    try {
        String result = apiInstance.accountPost(account);
        System.out.println(result);
    } catch (ApiException e) {
        System.err.println("Exception when calling AccountApi#accountPost");
        e.printStackTrace();
    }
  }
}

{
  "country": "country",
  "password": "password",
  "user_email": "user_email",
  "user_first_name": "user_first_name",
  "user_last_name": "user_last_name",
  "account_name": "account_name",
  "user_phone": "user_phone",
  "username": "username"
}

{
  "http_code": 200,
  "response_code": "SUCCESS",
  "response_msg": "Successfully created an account.",
  "data": {
    "user_id": 116,
    "username": "johndoe1",
    "user_email": "johndoe1@awesome.com",
    "active": 0,
    "banned": 0,
    "balance": "4.998000",
    "user_phone": "+15184811001",
    "reply_to": "originalemail",
    "delivery_to": null,
    "user_first_name": "John",
    "user_last_name": "Doe",
    "account": 0,
    "account_name": "The Awesome Company",
    "account_billing_email": "johndoe1@awesome.com",
    "account_billing_mobile": "+15184811001",
    "country": "US",
    "default_country_sms": "US",
    "auto_recharge": 0,
    "auto_recharge_amount": "20.00",
    "low_credit_amount": "0.00",
    "setting_unicode_sms": 0,
    "setting_email_sms_subject": 0,
    "setting_fix_sender_id": 0,
    "setting_sms_message_char_limit": 6,
    "old_dashboard": 0,
    "balance_commission": "0.299954",
    "timezone": "Australia/Melbourne",
    "_currency": {
      "currency_name_short": "USD",
      "currency_prefix_d": "$",
      "currency_prefix_c": "¢",
      "currency_name_long": "US Dollars"
    },
    "_subaccount": {
      "subaccount_id": 126,
      "api_username": "johndoe1",
      "email": "johndoe1@awesome.com",
      "phone_number": "+15184811001",
      "first_name": "John",
      "last_name": "Doe",
      "api_key": "F3702045-EB2C-0091-C211-7728048DCAE2",
      "access_users": 1,
      "access_billing": 1,
      "access_reporting": 1,
      "access_contacts": 1,
      "access_settings": 1,
      "access_sms": 1,
      "access_email": 1,
      "access_voice": 1,
      "access_fax": 1,
      "access_post": 1,
      "access_reseller": 1,
      "access_mms": 1,
      "share_campaigns": 0,
      "notes": null
    }
  }
}

curl --include \
     --header "Authorization: Basic YXBpLXVzZXJuYW1lOmFwaS1wYXNzd29yZA=="  \

'https://rest.clicksend.com/v3/account'

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

// Configure HTTP basic authorization: BasicAuth
$config = ClickSend\Configuration::getDefaultConfiguration()
              ->setUsername('USERNAME')
              ->setPassword('API_KEY');

$apiInstance = new ClickSend\Api\AccountApi(new GuzzleHttp\Client(),$config);

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

using IO.ClickSend.ClickSend.Api;
using IO.ClickSend.Client;

var configuration = new Configuration()
{
    Username = USERNAME, 
    Password = API_KEY  
};
var accountApi = new AccountApi(configuration);
var response = accountApi.AccountGet();

var api = require('./api.js');

var accountApi = new api.AccountApi("USERNAME", "API_KEY");

accountApi.accountGet().then(function(response) {
  console.log(response.body);
}).catch(function(err){
  console.error(err.body);
});

# load the gem
require 'clicksend_client'
require 'json'

# setup authorization
ClickSendClient.configure do |config|
  # Configure HTTP basic authorization: BasicAuth
  config.username = 'USERNAME'
  config.password = 'API_KEY'
end

api_instance = ClickSendClient::AccountApi.new

begin
  # Get account information
  result = api_instance.account_get
  p JSON.parse(result)
rescue ClickSendClient::ApiError => e
  puts "Exception when calling AccountApi->account_get: #{e.response_body}"
end

from __future__ import print_function
import clicksend_client
from clicksend_client.rest import ApiException

# Configure HTTP basic authorization: BasicAuth
configuration = clicksend_client.Configuration()
configuration.username = 'USERNAME'
configuration.password = 'API_KEY'

# create an instance of the API class
api_instance = clicksend_client.AccountApi(clicksend_client.ApiClient(configuration))

try:
    # Get account information
    api_response = api_instance.account_get()
    print(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->account_get: %s\n" % e)

use WWW::ClickSendClient::AccountApi;

my $username = 'YOUR_API_USER_NAME';
my $password = 'YOUR_API_PASSWORD';

my $api = WWW::ClickSendClient::AccountApi->new(username => $username, password => $password);

my $json_output = $api->account_get();

print $json_output;

#import "CSDefaultConfiguration.h"
#import "CSAccountApi.h"

CSDefaultConfiguration *apiConfig = [CSDefaultConfiguration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: BasicAuth)
[apiConfig setUsername:@"USERNAME"];
[apiConfig setPassword:@"PASSWORD"];

CSAccountApi *accountAPI = [[CSAccountApi alloc] init];
[accountAPI accountGetWithCompletionHandler:^(NSString *output, NSError *error) {
    if (error) {
        NSLog(@"Error: %@", error);
    } else {
        NSLog(@"Output: %@", output);
    }
}];

import Alamofire

if let authHeader = Request.authorizationHeader(user: "USERNAME", password: "PASSWORD") {
    ClickSendClientAPI.customHeaders = [authHeader.key : authHeader.value]
}

AccountAPI.accountGet { (dataString, error) in
    guard let dataString = dataString else {
        print(error!)
        return
    }

    if let data = dataString.data(using: String.Encoding.utf8) {
        do {
            if let dictonary = try (JSONSerialization.jsonObject(with: data, options: []) as? NSDictionary) {
                print(dictonary)
            } else {
                print("Cannot convert the String value to JSON")
            }
        } catch let error as NSError {
            print(error)
        }
    }
}

    Coming Soon

package ClickSend;

import ClickSend.Api.AccountApi;

public class view_account_detail {
  public static void main(String[] args) {
    ApiClient defaultClient = new ApiClient();
    defaultClient.setUsername("USERNAME");
    defaultClient.setPassword("API_KEY");
    AccountApi apiInstance = new AccountApi(defaultClient);
    try {
        String result = apiInstance.accountGet();
        System.out.println(result);
    } catch (ApiException e) {
        System.err.println("Exception when calling AccountApi#accountGet");
        e.printStackTrace();
    }
  }
}

{
  "http_code": 200,
  "response_code": "SUCCESS",
  "response_msg": "Here's your account",
  "data": {
    "user_id": 3819,
    "username": "ULXHP",
    "user_email": "PNUMB@VAPXX.com",
    "active": 1,
    "banned": 0,
    "balance": "1117.461060",
    "user_phone": "+61433333888",
    "user_first_name": "fffff",
    "user_last_name": "llll",
    "account": 0,
    "account_name": "FTHCQ~!@#$ %^&*()XQMPO",
    "account_billing_email": "XDVXC@SJRJU.com",
    "account_billing_mobile": "+61433333888",
    "country": "AU",
    "default_country_sms": "AU",
    "auto_recharge": 0,
    "auto_recharge_amount": "20.00",
    "low_credit_amount": "0.00",
    "setting_unicode_sms": 0,
    "setting_email_sms_subject": 0,
    "setting_fix_sender_id": 0,
    "setting_sms_message_char_limit": 8,
    "old_dashboard": 0,
    "balance_commission": "2.330130",
    "timezone": "Australia/Melbourne",
    "private_uploads": 0,
    "fax_quality": 0,
    "setting_sms_hide_your_number": 0,
    "setting_sms_hide_business_name": 1,
    "_currency": {
      "currency_name_short": "AUD",
      "currency_prefix_d": "$",
      "currency_prefix_c": "c",
      "currency_name_long": "Australian Dollars"
    },
    "_subaccount": {
      "subaccount_id": 1716,
      "api_username": "KCIHOYEYGM",
      "email": "ICMGR@VBSPT.com",
      "phone_number": "+61433333333",
      "first_name": "Firstname40710",
      "last_name": "Lastname3672",
      "api_key": "IJVEGTCF-VOHU-GSVF-KNKK-XHTARJXMQTXK",
      "access_users": 1,
      "access_billing": 1,
      "access_reporting": 1,
      "access_contacts": 0,
      "access_settings": 1,
      "access_sms": 0,
      "access_email": 0,
      "access_voice": 0,
      "access_fax": 0,
      "access_post": 0,
      "access_reseller": 0,
      "access_mms": 1,
      "share_campaigns": 1,
      "notes": null
    }
  }
}

curl --include \
     --header "Authorization: Basic YXBpLXVzZXJuYW1lOmFwaS1wYXNzd29yZA=="  \

'https://rest.clicksend.com/v3/account/usage/{year}/{month}/subaccount'

    Coming Soon

    Coming Soon

    Coming Soon

    Coming Soon

    Coming Soon

    Coming Soon

    Coming Soon

    Coming Soon

    Coming Soon

    Coming Soon

{
  "http_code": 200,
  "response_code": "SUCCESS",
  "response_msg": "Here is your usage for this month.",
  "data": {
    "sms": [
      {
        "subaccount_id": 1039,
        "username": "gerald",
        "total_count": "29.00",
        "total_price": "2.1337"
      },
      {
        "subaccount_id": 1047,
        "username": "user5",
        "total_count": "4.00",
        "total_price": "0.3080"
      }
    ],
    "voice": [
      {
        "subaccount_id": 1039,
        "username": "user1",
        "total_count": "6.00",
        "total_price": "0.1980"
      },
      {
        "subaccount_id": 1047,
        "username": "user5",
        "total_count": "1.00",
        "total_price": "0.0330"
      }
    ],
    "fax": [
      {
        "subaccount_id": 1039,
        "username": "user1",
        "total_count": "3.00",
        "total_price": "0.6943"
      },
      {
        "subaccount_id": 1047,
        "username": "user5",
        "total_count": "1.00",
        "total_price": "0.2314"
      }
    ],
    "post": [
      {
        "subaccount_id": 1039,
        "username": "user1",
        "total_count": "10",
        "total_price": "8.5624"
      },
      {
        "subaccount_id": 1047,
        "username": "user5",
        "total_count": "3",
        "total_price": "2.5586"
      }
    ],
    "email": [
      {
        "subaccount_id": 1039,
        "username": "user1",
        "total_count": 3992,
        "total_price": "9.0020"
      },
      {
        "subaccount_id": 1047,
        "username": "user5",
        "total_count": 998,
        "total_price": "0.0000"
      }
    ],
    "sms_total": {
      "count": 33,
      "price": "2.4417"
    },
    "voice_total": {
      "count": 7,
      "price": "0.2310"
    },
    "fax_total": {
      "count": 4,
      "price": "0.9257"
    },
    "post_total": {
      "count": 13,
      "price": "11.1210"
    },
    "email_total": {
      "count": 4990,
      "price": "9.0020"
    }
  }
}

curl --include \
     --request PUT \
     --header "Content-Type: application/json" \
     --data-binary "    {
        \"phone_number\": \"3108147982\",
        \"email\": \"test@email.com\"
    }" \
'https://rest.clicksend.com/v3/forgot-username'

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

$apiInstance = new ClickSend\Api\AccountApi(new GuzzleHttp\Client());
$forgot_username = new \ClickSend\Model\ForgotUsername(); // \ClickSend\Model\ForgotUsername | 
$forgot_username->setEmail("xxx@gmail.com");

try {
    $result = $apiInstance->forgotUsernamePut($forgot_username);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AccountApi->forgotUsernamePut: ', $e->getMessage(), PHP_EOL;
}
?>

using IO.ClickSend.ClickSend.Api;
using IO.ClickSend.Client;

var accountApi = new AccountApi(Configuration.Default);
var response = accountApi.ForgotUsernamePut(new ForgotUsername(
    email: "john@doe.com"
));

var api = require('./api.js');

var accountApi = new api.AccountApi("USERNAME", "API_KEY");

var forgotUsername = new  api.ForgotUsername();

forgotUsername.email = "xxx@gmail.com";
forgotUsername.phoneNumber = "xxx-xxx-xxxx";

accountApi.forgotUsernamePut(forgotUsername).then(function(response) {
  console.log(response.body);
}).catch(function(err){
  console.error(err.body);
});

# load the gem
require 'clicksend_client'
require 'json'

api_instance = ClickSendClient::AccountApi.new

opts = {
  forgot_username: ClickSendClient::ForgotUsername.new( # ForgotUsername | ForgotUsername model
    "email": "test@email.com"
  )
}

begin
  # Forgot username
  result = api_instance.forgot_username_put(opts)
  p JSON.parse(result)
rescue ClickSendClient::ApiError => e
  puts "Exception when calling AccountApi->forgot_username_put: #{e.response_body}"
end

from __future__ import print_function
import clicksend_client
from clicksend_client.rest import ApiException

# create an instance of the API class
api_instance = clicksend_client.AccountApi()
forgot_username = clicksend_client.ForgotUsername(
                  email='xxx@gmail.com',
                  phone_number= '000-000-0000') # ForgotUsername |  (optional)

try:
    # Forgot username
    api_response = api_instance.forgot_username_put(forgot_username=forgot_username)
    print(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->forgot_username_put: %s\n" % e)

use WWW::ClickSendClient::AccountApi;

my $api         = WWW::ClickSendClient::AccountApi->new();
my $email       = 'YOUR_EMAIL';

my $json_output = $api->forgot_username_put('email' => $email);

print $json_output;

#import "CSDefaultConfiguration.h"
#import "CSAccountApi.h"

CSDefaultConfiguration *apiConfig = [CSDefaultConfiguration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: BasicAuth)
[apiConfig setUsername:@"USERNAME"];
[apiConfig setPassword:@"PASSWORD"];

CSAccountApi *accountAPI = [[CSAccountApi alloc] init];
CSForgotUsername *forgotUserName = [[CSForgotUsername alloc] init];
forgotUserName.email = @"johndoe1@gmail.com";
forgotUserName.phoneNumber = @"3108147982";

[accountAPI forgotUsernamePutWithForgotUsername:forgotUserName completionHandler:^(NSString *output, NSError *error) {
    if (error) {
        NSLog(@"Error: %@", error);
    } else {
        NSLog(@"%@", output);
    }
}];

import Alamofire

if let authHeader = Request.authorizationHeader(user: "USERNAME", password: "PASSWORD") {
    ClickSendClientAPI.customHeaders = [authHeader.key : authHeader.value]
}

let forgotUserName = ForgotUsername(
    email: "johndoe1@gmail.com", 
    phoneNumber: "3108147982"
)

AccountAPI.forgotUsernamePut(forgotUsername: forgotUserName) { (dataString, error) in
    guard let dataString = dataString else {
        print(error!)
        return
    }

    if let data = dataString.data(using: String.Encoding.utf8) {
        do {
            if let dictonary = try (JSONSerialization.jsonObject(with: data, options: []) as? NSDictionary) {
                print(dictonary)
            } else {
                print("Cannot convert the String value to JSON")
            }
        } catch let error as NSError {
            print(error)
        }
    }
}

    Coming Soon

package ClickSend;

import ClickSend.Api.AccountApi;
import ClickSend.Model.ForgotUsername;

public class forgot_username {
  public static void main(String[] args) {
    ApiClient defaultClient = new ApiClient();
    defaultClient.setUsername("USERNAME");
    defaultClient.setPassword("API_KEY");
    AccountApi apiInstance = new AccountApi(defaultClient);
    ForgotUsername forgotUsername = new ForgotUsername(); // ForgotUsername | 
    forgotUsername.email("xxx@gmail.com");
    forgotUsername.phoneNumber("xxx-xxx-xxxx");
    try {
        String result = apiInstance.forgotUsernamePut(forgotUsername);
        System.out.println(result);
    } catch (ApiException e) {
        System.err.println("Exception when calling AccountApi#forgotUsernamePut");
        e.printStackTrace();
    }
  }
}

{
  "phone_number": "3108147982",
  "email": "test@email.com"
}

{
  "http_code": 200,
  "response_code": "SUCCESS",
  "response_msg": "An email notification has been sent.",
  "data": []
}

curl --include \
     --request PUT \
     --header "Content-Type: application/json" \
     --data-binary "    {
        \"username\": \"0F6pKiiuca\"
    }" \
'https://rest.clicksend.com/v3/forgot-password'

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

// Configure HTTP basic authorization: BasicAuth
$config = ClickSend\Configuration::getDefaultConfiguration()
              ->setUsername('USERNAME')
              ->setPassword('API_KEY');

$apiInstance = new ClickSend\Api\AccountApi(new GuzzleHttp\Client(),$config);
$forgot_password = new \ClickSend\Model\ForgotPassword(); // \ClickSend\Model\ForgotPassword | 
$forgot_password->username="username";

try {
    $result = $apiInstance->forgotPasswordPut($forgot_password);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AccountApi->forgotPasswordPut: ', $e->getMessage(), PHP_EOL;
}
?>

using IO.ClickSend.ClickSend.Api;
using IO.ClickSend.Client;

var accountApi = new AccountApi(Configuration.Default);
var response = accountApi.ForgotPasswordPut(USERNAME);

var api = require('./api.js');

var accountApi = new api.AccountApi("USERNAME", "API_KEY");

var forgotPassword = new  api.ForgotPassword();

forgotPassword.username = "xxx@gmail.com";

accountApi.forgotPasswordPut(forgotPassword).then(function(response) {
  console.log(response.body);
}).catch(function(err){
  console.error(err.body);
});

# load the gem
require 'clicksend_client'
require 'json'

# setup authorization
ClickSendClient.configure do |config|
  # Configure HTTP basic authorization: BasicAuth
  config.username = 'USERNAME'
  config.password = 'API_KEY'
end

api_instance = ClickSendClient::AccountApi.new

# ForgotPassword |
opts = {
  forgot_password: ClickSendClient::ForgotPassword.new(
    "username": "0F6pKiiuca"
  )
}

begin
  # Forgot password
  result = api_instance.forgot_password_put(opts)
  p JSON.parse(result)
rescue ClickSendClient::ApiError => e
  puts "Exception when calling AccountApi->forgot_password_put: #{e.response_body}"
end

from __future__ import print_function
import clicksend_client
from clicksend_client.rest import ApiException

# Configure HTTP basic authorization: BasicAuth
configuration = clicksend_client.Configuration()
configuration.username = 'USERNAME'
configuration.password = 'API_KEY'

# create an instance of the API class
api_instance = clicksend_client.AccountApi(clicksend_client.ApiClient(configuration))
forgot_password = clicksend_client.ForgotPassword(username='USERNAME') # ForgotPassword |  (optional)

try:
    # Forgot password
    api_response = api_instance.forgot_password_put(forgot_password=forgot_password)
    print(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->forgot_password_put: %s\n" % e)

use WWW::ClickSendClient::AccountApi;

my $api = WWW::ClickSendClient::AccountApi->new();

my $username = 'YOUR_USER_NAME';

my $json_output = $api->forgot_password_put('username' => $username);
print $json_output;

#import "CSDefaultConfiguration.h"
#import "CSAccountApi.h"

CSDefaultConfiguration *apiConfig = [CSDefaultConfiguration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: BasicAuth)
[apiConfig setUsername:@"USERNAME"];
[apiConfig setPassword:@"PASSWORD"];

CSAccountApi *accountAPI = [[CSAccountApi alloc] init];

CSForgotPassword *forgotPassword = [[CSForgotPassword alloc] init];
forgotPassword.username = @"USERNAME";

[accountAPI forgotPasswordPutWithForgotPassword:forgotPassword completionHandler:^(NSString *output, NSError *error) {
    if (error) {
        NSLog(@"Error: %@", error);
    } else {
        NSLog(@"%@", output);
    }
}];

import Alamofire

if let authHeader = Request.authorizationHeader(user: "USERNAME", password: "PASSWORD") {
    ClickSendClientAPI.customHeaders = [authHeader.key : authHeader.value]
}

let forgotPassword = ForgotPassword(username: "USERNAME")

AccountAPI.forgotPasswordPut(forgotPassword: forgotPassword) { (dataString, error) in
    guard let dataString = dataString else {
        print(error!)
        return
    }

    if let data = dataString.data(using: String.Encoding.utf8) {
        do {
            if let dictonary = try (JSONSerialization.jsonObject(with: data, options: []) as? NSDictionary) {
                print(dictonary)
            } else {
                print("Cannot convert the String value to JSON")
            }
        } catch let error as NSError {
            print(error)
        }
    }
}

    Coming Soon

package ClickSend;

import ClickSend.Api.AccountApi;
import ClickSend.Model.ForgotPassword;

public class forgot_password {
  public static void main(String[] args) {
    ApiClient defaultClient = new ApiClient();
    defaultClient.setUsername("USERNAME");
    defaultClient.setPassword("API_KEY");
    AccountApi apiInstance = new AccountApi(defaultClient);
    ForgotPassword forgotPassword = new ForgotPassword(); // ForgotPassword | 
    forgotPassword.username("USERNAME");
    try {
        String result = apiInstance.forgotPasswordPut(forgotPassword);
        System.out.println(result);
    } catch (ApiException e) {
        System.err.println("Exception when calling AccountApi#forgotPasswordPut");
        e.printStackTrace();
    }
  }
}

{
  "username": "0F6pKiiuca"
}

{
  "http_code": 200,
  "response_code": "SUCCESS",
  "response_msg": "An email notification has been sent.",
  "data": []
}

curl --include \
     --request PUT \
     --header "Content-Type: application/json" \
     --data-binary "    {
        \"subaccount_id\": 54,
        \"activation_token\": \"9C648BAD-EB7F-4E7E-96BC-B433140C4F1F\",
        \"password\": \"0F6pKiiuca\"
    }" \
'https://rest.clicksend.com/v3/forgot-password/verify'

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

// Configure HTTP basic authorization: BasicAuth
$config = ClickSend\Configuration::getDefaultConfiguration()
              ->setUsername('USERNAME')
              ->setPassword('API_KEY');

$apiInstance = new ClickSend\Api\AccountApi(new GuzzleHttp\Client(),$config);
// \ClickSend\Model\AccountForgotPasswordVerify | verifyPassword data
$verify_password = new \ClickSend\Model\AccountForgotPasswordVerify(); 
$verify_password->setSubaccountId("82267");
$verify_password->setActivationToken("67B187C4-FD56-42E3-AE22-60A2E23F6593");
$verify_password->setPassword("123");

try {
    $result = $apiInstance->forgotPasswordVerifyPut($verify_password);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AccountApi->forgotPasswordVerifyPut: ', $e->getMessage(), PHP_EOL;
}
?>

using IO.ClickSend.ClickSend.Api;
using IO.ClickSend.Client;
using IO.ClickSend.ClickSend.Model;

var accountApi = new AccountApi(Configuration.Default);
var response = accountApi.ForgotPasswordVerifyPut(new AccountForgotPasswordVerify() {
    SubaccountId = 1234,
    ActivationToken = "activation_token",
    Password = "password"
});

var api = require('./api.js');

var accountApi = new api.AccountApi("USERNAME", "API_KEY");

var verifyPassword = new  api.AccountForgotPasswordVerify();

verifyPassword.subaccountId = 1392;
verifyPassword.acctivationToken = "7A7616E8-1FC3-4918-975F-D303B65B1523";
verifyPassword.password = "123";

accountApi.forgotPasswordVerifyPut(verifyPassword).then(function(response) {
  console.log(response.body);
}).catch(function(err){
  console.error(err.body);
});

# load the gem
require 'clicksend_client'
require 'json'

# setup authorization
ClickSendClient.configure do |config|
  # Configure HTTP basic authorization: BasicAuth
  config.username = 'USERNAME'
  config.password = 'API_KEY'
end

api_instance = ClickSendClient::AccountApi.new

# AccountForgotPasswordVerify | verifyPassword data
verify_password = ClickSendClient::AccountForgotPasswordVerify.new(
  "activation_token": "activation_token",
  "password": "password",
  "subaccount_id": 0
)

begin
  # Verify forgot password
  result = api_instance.forgot_password_verify_put(verify_password)
  p JSON.parse(result)
rescue ClickSendClient::ApiError => e
  puts "Exception when calling AccountApi->forgot_password_verify_put: #{e.response_body}"
end

from __future__ import print_function
import clicksend_client
from clicksend_client.rest import ApiException

# Configure HTTP basic authorization: BasicAuth
configuration = clicksend_client.Configuration()
configuration.username = 'USERNAME'
configuration.password = 'API_KEY'

# create an instance of the API class
api_instance = clicksend_client.AccountApi(clicksend_client.ApiClient(configuration))
verify_password = clicksend_client.AccountForgotPasswordVerify(
                  subaccount_id= '74275',
                  activation_token='67B187C4-FD56-42E3-AE22-60A2E23F6593',
                  password='123') # AccountForgotPasswordVerify | verifyPassword data

try:
    # Verify forgot password
    api_response = api_instance.forgot_password_verify_put(verify_password)
    print(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->forgot_password_verify_put: %s\n" % e)

use WWW::ClickSendClient::AccountApi;
use WWW::ClickSendClient::Object::AccountForgotPasswordVerify;

my $api = WWW::ClickSendClient::AccountApi->new();

my %params = (
    'subaccount_id'    => 1234,
    'activation_token' => 'XXXXXXXX-XXXXXXXX-XXXXXXXX-XXXXXXXX-XXXXXXXX',
    'password'         => 'XXXXXXXX',
);

my $verify_password_obj = WWW::ClickSendClient::Object::AccountForgotPasswordVerify->new(%params);

my $json_output = $api->forgot_password_verify_put('verify_password' => $verify_password_obj);

print $json_output;

#import "CSDefaultConfiguration.h"
#import "CSAccountApi.h"

CSDefaultConfiguration *apiConfig = [CSDefaultConfiguration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: BasicAuth)
[apiConfig setUsername:@"USERNAME"];
[apiConfig setPassword:@"PASSWORD"];

CSAccountForgotPasswordVerify *accountForgotPasswordVerify = [[CSAccountForgotPasswordVerify alloc] init];
accountForgotPasswordVerify.subaccountId = 0;
accountForgotPasswordVerify.activationToken = @"activation";
accountForgotPasswordVerify.password = @"password";

CSAccountApi *accountApiInstance = [[CSAccountApi alloc] init];

[accountApiInstance forgotPasswordVerifyPutWithVerifyPassword:accountForgotPasswordVerify completionHandler:^(NSString *output, NSError *error) {
    if (error) {
        NSLog(@"Error: %@", error);
    } else {
        NSLog(@"%@", output);
    }
}];

import Alamofire

if let authHeader = Request.authorizationHeader(user: "USERNAME", password: "PASSWORD") {
    ClickSendClientAPI.customHeaders = [authHeader.key : authHeader.value]
}


let  verifyPassword = AccountForgotPasswordVerify(subaccountId: 1,
                                                  activationToken: "activation_token",
                                                  password: "pasword"
                                                  )
AccountAPI.forgotPasswordVerifyPut(verifyPassword: verifyPassword) { (dataString, error) in
    guard let dataString = dataString else {
        print(error!)
        return
    }

    if let data = dataString.data(using: String.Encoding.utf8) {
        do {
            if let dictonary = try (JSONSerialization.jsonObject(with: data, options: []) as? NSDictionary) {
                print(dictonary)
            } else {
                print("Cannot convert the String value to JSON")
            }
        } catch let error as NSError {
            print(error)
        }
    }
}

    Coming Soon

package ClickSend;

import ClickSend.Api.AccountApi;
import ClickSend.Model.AccountForgotPasswordVerify;

public class verify_forgot_password {
  public static void main(String[] args) {
    ApiClient defaultClient = new ApiClient();
    defaultClient.setUsername("USERNAME");
    defaultClient.setPassword("API_KEY");
    AccountApi apiInstance = new AccountApi(defaultClient);
    // AccountForgotPasswordVerify | verifyPassword data
    AccountForgotPasswordVerify verifyPassword = new AccountForgotPasswordVerify(); 
    verifyPassword.activationToken("8ED1EF5E-6B40-41C1-8992-7A5A22D261F8");
    verifyPassword.subaccountId(new Integer(74275));
    verifyPassword.password("abc");
    try {
        String result = apiInstance.forgotPasswordVerifyPut(verifyPassword);
        System.out.println(result);
    } catch (ApiException e) {
        System.err.println("Exception when calling AccountApi#forgotPasswordVerifyPut");
        e.printStackTrace();
    }
  }
}

{
  "activation_token": "activation_token",
  "password": "password",
  "subaccount_id": 0
}

{
  "http_code": 200,
  "response_code": "SUCCESS",
  "response_msg": "Your password has been updated.",
  "data": []
}

curl --include \
     --header "Authorization: Basic YXBpLXVzZXJuYW1lOmFwaS1wYXNzd29yZA=="  \
'https://rest.clicksend.com/v3/recharge/credit-card'

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

// Configure HTTP basic authorization: BasicAuth
$config = ClickSend\Configuration::getDefaultConfiguration()
              ->setUsername('USERNAME')
              ->setPassword('API_KEY');

$apiInstance = new ClickSend\Api\AccountRechargeApi(new GuzzleHttp\Client(),$config);

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

using IO.ClickSend.ClickSend.Api;
using IO.ClickSend.Client;

var configuration = new Configuration()
{
    Username = USERNAME, 
    Password = API_KEY  
};
var accountRechargeApi = new AccountRechargeApi(configuration);
var response = accountRechargeApi.RechargeCreditCardGet();

var api = require('./api.js');

var accountRechargeApi = new api.AccountRechargeApi("USERNAME", "API_KEY");

accountRechargeApi.rechargeCreditCardGet().then(function(response) {
  console.log(response.body);
}).catch(function(err){
  console.error(err.body);
});

# load the gem
require 'clicksend_client'
require 'json'

# setup authorization
ClickSendClient.configure do |config|
  # Configure HTTP basic authorization: BasicAuth
  config.username = 'USERNAME'
  config.password = 'API_KEY'
end

api_instance = ClickSendClient::AccountRechargeApi.new

begin
  # Get Credit Card info
  result = api_instance.recharge_credit_card_get
  p JSON.parse(result)
rescue ClickSendClient::ApiError => e
  puts "Exception when calling AccountRechargeApi->recharge_credit_card_get: #{e.response_body}"
end

from __future__ import print_function
import clicksend_client
from clicksend_client.rest import ApiException

# Configure HTTP basic authorization: BasicAuth
configuration = clicksend_client.Configuration()
configuration.username = 'USERNAME'
configuration.password = 'API_KEY'

# create an instance of the API class
api_instance = clicksend_client.AccountRechargeApi(clicksend_client.ApiClient(configuration))

try:
    # Get Credit Card info
    api_response = api_instance.recharge_credit_card_get()
    print(api_response)
except ApiException as e:
    print("Exception when calling AccountRechargeApi->recharge_credit_card_get: %s\n" % e)

use WWW::ClickSendClient::AccountRechargeApi;

my $username = 'YOUR_API_USER_NAME';
my $password = 'YOUR_API_PASSWORD';

my $api = WWW::ClickSendClient::AccountRechargeApi->new(username => $username, password => $password);

my $json_output = $api->recharge_credit_card_get();

print $json_output;

#import "CSAccountRechargeApi.h"

CSDefaultConfiguration *apiConfig = [CSDefaultConfiguration sharedConfig];
[apiConfig setUsername:@"USERNAME"];
[apiConfig setPassword:@"PASSWORD"];

CSAccountRechargeApi *accountRechargeApiInstance = [[CSAccountRechargeApi alloc] init];
[accountRechargeApiInstance rechargeCreditCardGetWithCompletionHandler:^(NSString *output, NSError *error) {
    if (error) {
        NSLog(@"Error: %@", error);
    } else {
        NSLog(@"%@", output);
    }
}];

import Alamofire

if let authHeader = Request.authorizationHeader(user: "USERNAME", password: "PASSWORD") {
    ClickSendClientAPI.customHeaders = [authHeader.key : authHeader.value]
}

AccountRechargeAPI.rechargeCreditCardGet { (dataString, error) in
    guard let dataString = dataString else {
        print(error!)
        return
    }
    if let data = dataString.data(using: String.Encoding.utf8) {
        do {
        if let dictonary = try (JSONSerialization.jsonObject(with: data, options: []) as? NSDictionary) {
                print(dictonary)
            } else {
                print("Cannot convert the String value to JSON")
            }
        } catch let error as NSError {
            print(error)
        }
    }
}

    Coming Soon

package ClickSend;

import ClickSend.Api.AccountRechargeApi;

public class current_payment_info {
  public static void main(String[] args) {
    ApiClient defaultClient = new ApiClient();
    defaultClient.setUsername("USERNAME");
    defaultClient.setPassword("API_KEY");
    AccountRechargeApi apiInstance = new AccountRechargeApi(defaultClient);
    try {
        String result = apiInstance.rechargeCreditCardGet();
        System.out.println(result);
    } catch (ApiException e) {
        System.err.println("Exception when calling AccountRechargeApi#rechargeCreditCardGet");
        e.printStackTrace();
    }
  }
}

{
  "http_code": 200,
  "response_code": "SUCCESS",
  "response_msg": "Customer payment info.",
  "data": {
    "display_number": "XXXX-XXXX-XXXX-0000",
    "expiry_month": 5,
    "expiry_year": 2016,
    "name": "Roland Robot"
  }
}

curl --include \
     --header "Authorization: Basic YXBpLXVzZXJuYW1lOmFwaS1wYXNzd29yZA=="  \
     --request PUT \
     --header "Content-Type: application/json" \

     --data-binary "    {
        \"number\":\"5520000000000000\",
        \"expiry_month\":\"05\",
        \"expiry_year\":\"2016\",
        \"cvc\":\"123\",
        \"name\":\"Roland Robot\",
        \"bank_name\": \"Robotic Banking\"
    }" \
'https://rest.clicksend.com/v3/recharge/credit-card'

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

// Configure HTTP basic authorization: BasicAuth
$config = ClickSend\Configuration::getDefaultConfiguration()
              ->setUsername('USERNAME')
              ->setPassword('API_KEY');

$apiInstance = new ClickSend\Api\AccountRechargeApi(new GuzzleHttp\Client(),$config);
// \ClickSend\Model\CreditCard | CreditCard model
$credit_card = new \ClickSend\Model\CreditCard(); 
$credit_card->setNumber("5520000000000000");
$credit_card->setExpiryMonth("05");
$credit_card->setExpiryYear("2019");
$credit_card->setCvc("123");
$credit_card->setName("Roland Robot");
$credit_card->setBankName("Robotic Banking");

try {
    $result = $apiInstance->rechargeCreditCardPut($credit_card);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AccountRechargeApi->rechargeCreditCardPut: ', $e->getMessage(), PHP_EOL;
}
?>