import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CartApi;

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

public class CartApiExample {

    public static void main(String[] args) {
        
        CartApi apiInstance = new CartApi();
        Checkout_uuid_body body = ; // Checkout_uuid_body | 
        String uuid = uuid_example; // String | The uuid to be used by CM
        try {
            executeActionResponse result = apiInstance.cartCheckoutUuidPost(body, uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CartApi#cartCheckoutUuidPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CartApi;

public class CartApiExample {

    public static void main(String[] args) {
        CartApi apiInstance = new CartApi();
        Checkout_uuid_body body = ; // Checkout_uuid_body | 
        String uuid = uuid_example; // String | The uuid to be used by CM
        try {
            executeActionResponse result = apiInstance.cartCheckoutUuidPost(body, uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CartApi#cartCheckoutUuidPost");
            e.printStackTrace();
        }
    }
}

Checkout_uuid_body *body = ; // 
String *uuid = uuid_example; // The uuid to be used by CM

CartApi *apiInstance = [[CartApi alloc] init];

// Complete the order and checkout
[apiInstance cartCheckoutUuidPostWith:body
    uuid:uuid
              completionHandler: ^(executeActionResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TokkioCartManager = require('tokkio_cart_manager');

var api = new TokkioCartManager.CartApi()
var body = ; // {{Checkout_uuid_body}} 
var uuid = uuid_example; // {{String}} The uuid to be used by CM

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new CartApi();
            var body = new Checkout_uuid_body(); // Checkout_uuid_body | 
            var uuid = uuid_example;  // String | The uuid to be used by CM

            try
            {
                // Complete the order and checkout
                executeActionResponse result = apiInstance.cartCheckoutUuidPost(body, uuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CartApi.cartCheckoutUuidPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCartApi();
$body = ; // Checkout_uuid_body | 
$uuid = uuid_example; // String | The uuid to be used by CM

try {
    $result = $api_instance->cartCheckoutUuidPost($body, $uuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CartApi->cartCheckoutUuidPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CartApi;

my $api_instance = WWW::SwaggerClient::CartApi->new();
my $body = WWW::SwaggerClient::Object::Checkout_uuid_body->new(); # Checkout_uuid_body | 
my $uuid = uuid_example; # String | The uuid to be used by CM

eval { 
    my $result = $api_instance->cartCheckoutUuidPost(body => $body, uuid => $uuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CartApi->cartCheckoutUuidPost: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.CartApi()
body =  # Checkout_uuid_body | 
uuid = uuid_example # String | The uuid to be used by CM

try: 
    # Complete the order and checkout
    api_response = api_instance.cart_checkout_uuid_post(body, uuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CartApi->cartCheckoutUuidPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CartApi;

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

public class CartApiExample {

    public static void main(String[] args) {
        
        CartApi apiInstance = new CartApi();
        Add_uuid_body body = ; // Add_uuid_body | 
        String uuid = uuid_example; // String | The uuid to be used by CM
        try {
            item_cart result = apiInstance.cartItemsAddUuidPost(body, uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CartApi#cartItemsAddUuidPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CartApi;

public class CartApiExample {

    public static void main(String[] args) {
        CartApi apiInstance = new CartApi();
        Add_uuid_body body = ; // Add_uuid_body | 
        String uuid = uuid_example; // String | The uuid to be used by CM
        try {
            item_cart result = apiInstance.cartItemsAddUuidPost(body, uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CartApi#cartItemsAddUuidPost");
            e.printStackTrace();
        }
    }
}

Add_uuid_body *body = ; // 
String *uuid = uuid_example; // The uuid to be used by CM

CartApi *apiInstance = [[CartApi alloc] init];

// Add items to the cart
[apiInstance cartItemsAddUuidPostWith:body
    uuid:uuid
              completionHandler: ^(item_cart output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TokkioCartManager = require('tokkio_cart_manager');

var api = new TokkioCartManager.CartApi()
var body = ; // {{Add_uuid_body}} 
var uuid = uuid_example; // {{String}} The uuid to be used by CM

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new CartApi();
            var body = new Add_uuid_body(); // Add_uuid_body | 
            var uuid = uuid_example;  // String | The uuid to be used by CM

            try
            {
                // Add items to the cart
                item_cart result = apiInstance.cartItemsAddUuidPost(body, uuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CartApi.cartItemsAddUuidPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCartApi();
$body = ; // Add_uuid_body | 
$uuid = uuid_example; // String | The uuid to be used by CM

try {
    $result = $api_instance->cartItemsAddUuidPost($body, $uuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CartApi->cartItemsAddUuidPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CartApi;

my $api_instance = WWW::SwaggerClient::CartApi->new();
my $body = WWW::SwaggerClient::Object::Add_uuid_body->new(); # Add_uuid_body | 
my $uuid = uuid_example; # String | The uuid to be used by CM

eval { 
    my $result = $api_instance->cartItemsAddUuidPost(body => $body, uuid => $uuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CartApi->cartItemsAddUuidPost: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.CartApi()
body =  # Add_uuid_body | 
uuid = uuid_example # String | The uuid to be used by CM

try: 
    # Add items to the cart
    api_response = api_instance.cart_items_add_uuid_post(body, uuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CartApi->cartItemsAddUuidPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CartApi;

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

public class CartApiExample {

    public static void main(String[] args) {
        
        CartApi apiInstance = new CartApi();
        String uuid = uuid_example; // String | The uuid to be used by CM
        String cartItemId = cartItemId_example; // String | The cartItemId to be used by CM
        try {
            executeActionResponse result = apiInstance.cartItemsDeleteByCartItemIdUuidCartItemIdDelete(uuid, cartItemId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CartApi#cartItemsDeleteByCartItemIdUuidCartItemIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CartApi;

public class CartApiExample {

    public static void main(String[] args) {
        CartApi apiInstance = new CartApi();
        String uuid = uuid_example; // String | The uuid to be used by CM
        String cartItemId = cartItemId_example; // String | The cartItemId to be used by CM
        try {
            executeActionResponse result = apiInstance.cartItemsDeleteByCartItemIdUuidCartItemIdDelete(uuid, cartItemId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CartApi#cartItemsDeleteByCartItemIdUuidCartItemIdDelete");
            e.printStackTrace();
        }
    }
}

String *uuid = uuid_example; // The uuid to be used by CM
String *cartItemId = cartItemId_example; // The cartItemId to be used by CM

CartApi *apiInstance = [[CartApi alloc] init];

// Delete an item from the cart using its cart item id
[apiInstance cartItemsDeleteByCartItemIdUuidCartItemIdDeleteWith:uuid
    cartItemId:cartItemId
              completionHandler: ^(executeActionResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TokkioCartManager = require('tokkio_cart_manager');

var api = new TokkioCartManager.CartApi()
var uuid = uuid_example; // {{String}} The uuid to be used by CM
var cartItemId = cartItemId_example; // {{String}} The cartItemId to be used by CM

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new CartApi();
            var uuid = uuid_example;  // String | The uuid to be used by CM
            var cartItemId = cartItemId_example;  // String | The cartItemId to be used by CM

            try
            {
                // Delete an item from the cart using its cart item id
                executeActionResponse result = apiInstance.cartItemsDeleteByCartItemIdUuidCartItemIdDelete(uuid, cartItemId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CartApi.cartItemsDeleteByCartItemIdUuidCartItemIdDelete: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCartApi();
$uuid = uuid_example; // String | The uuid to be used by CM
$cartItemId = cartItemId_example; // String | The cartItemId to be used by CM

try {
    $result = $api_instance->cartItemsDeleteByCartItemIdUuidCartItemIdDelete($uuid, $cartItemId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CartApi->cartItemsDeleteByCartItemIdUuidCartItemIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CartApi;

my $api_instance = WWW::SwaggerClient::CartApi->new();
my $uuid = uuid_example; # String | The uuid to be used by CM
my $cartItemId = cartItemId_example; # String | The cartItemId to be used by CM

eval { 
    my $result = $api_instance->cartItemsDeleteByCartItemIdUuidCartItemIdDelete(uuid => $uuid, cartItemId => $cartItemId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CartApi->cartItemsDeleteByCartItemIdUuidCartItemIdDelete: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.CartApi()
uuid = uuid_example # String | The uuid to be used by CM
cartItemId = cartItemId_example # String | The cartItemId to be used by CM

try: 
    # Delete an item from the cart using its cart item id
    api_response = api_instance.cart_items_delete_by_cart_item_id_uuid_cart_item_id_delete(uuid, cartItemId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CartApi->cartItemsDeleteByCartItemIdUuidCartItemIdDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CartApi;

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

public class CartApiExample {

    public static void main(String[] args) {
        
        CartApi apiInstance = new CartApi();
        Delete_uuid_body body = ; // Delete_uuid_body | 
        String uuid = uuid_example; // String | The uuid to be used by CM
        try {
            executeActionResponse result = apiInstance.cartItemsDeleteUuidPut(body, uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CartApi#cartItemsDeleteUuidPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CartApi;

public class CartApiExample {

    public static void main(String[] args) {
        CartApi apiInstance = new CartApi();
        Delete_uuid_body body = ; // Delete_uuid_body | 
        String uuid = uuid_example; // String | The uuid to be used by CM
        try {
            executeActionResponse result = apiInstance.cartItemsDeleteUuidPut(body, uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CartApi#cartItemsDeleteUuidPut");
            e.printStackTrace();
        }
    }
}

Delete_uuid_body *body = ; // 
String *uuid = uuid_example; // The uuid to be used by CM

CartApi *apiInstance = [[CartApi alloc] init];

// Delete an item from the cart
[apiInstance cartItemsDeleteUuidPutWith:body
    uuid:uuid
              completionHandler: ^(executeActionResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TokkioCartManager = require('tokkio_cart_manager');

var api = new TokkioCartManager.CartApi()
var body = ; // {{Delete_uuid_body}} 
var uuid = uuid_example; // {{String}} The uuid to be used by CM

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new CartApi();
            var body = new Delete_uuid_body(); // Delete_uuid_body | 
            var uuid = uuid_example;  // String | The uuid to be used by CM

            try
            {
                // Delete an item from the cart
                executeActionResponse result = apiInstance.cartItemsDeleteUuidPut(body, uuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CartApi.cartItemsDeleteUuidPut: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCartApi();
$body = ; // Delete_uuid_body | 
$uuid = uuid_example; // String | The uuid to be used by CM

try {
    $result = $api_instance->cartItemsDeleteUuidPut($body, $uuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CartApi->cartItemsDeleteUuidPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CartApi;

my $api_instance = WWW::SwaggerClient::CartApi->new();
my $body = WWW::SwaggerClient::Object::Delete_uuid_body->new(); # Delete_uuid_body | 
my $uuid = uuid_example; # String | The uuid to be used by CM

eval { 
    my $result = $api_instance->cartItemsDeleteUuidPut(body => $body, uuid => $uuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CartApi->cartItemsDeleteUuidPut: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.CartApi()
body =  # Delete_uuid_body | 
uuid = uuid_example # String | The uuid to be used by CM

try: 
    # Delete an item from the cart
    api_response = api_instance.cart_items_delete_uuid_put(body, uuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CartApi->cartItemsDeleteUuidPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CartApi;

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

public class CartApiExample {

    public static void main(String[] args) {
        
        CartApi apiInstance = new CartApi();
        Replace_uuid_body body = ; // Replace_uuid_body | 
        String uuid = uuid_example; // String | The uuid to be used by CM
        try {
            executeActionResponse result = apiInstance.cartItemsReplaceUuidPut(body, uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CartApi#cartItemsReplaceUuidPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CartApi;

public class CartApiExample {

    public static void main(String[] args) {
        CartApi apiInstance = new CartApi();
        Replace_uuid_body body = ; // Replace_uuid_body | 
        String uuid = uuid_example; // String | The uuid to be used by CM
        try {
            executeActionResponse result = apiInstance.cartItemsReplaceUuidPut(body, uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CartApi#cartItemsReplaceUuidPut");
            e.printStackTrace();
        }
    }
}

Replace_uuid_body *body = ; // 
String *uuid = uuid_example; // The uuid to be used by CM

CartApi *apiInstance = [[CartApi alloc] init];

// Replace an item from the cart
[apiInstance cartItemsReplaceUuidPutWith:body
    uuid:uuid
              completionHandler: ^(executeActionResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TokkioCartManager = require('tokkio_cart_manager');

var api = new TokkioCartManager.CartApi()
var body = ; // {{Replace_uuid_body}} 
var uuid = uuid_example; // {{String}} The uuid to be used by CM

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new CartApi();
            var body = new Replace_uuid_body(); // Replace_uuid_body | 
            var uuid = uuid_example;  // String | The uuid to be used by CM

            try
            {
                // Replace an item from the cart
                executeActionResponse result = apiInstance.cartItemsReplaceUuidPut(body, uuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CartApi.cartItemsReplaceUuidPut: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCartApi();
$body = ; // Replace_uuid_body | 
$uuid = uuid_example; // String | The uuid to be used by CM

try {
    $result = $api_instance->cartItemsReplaceUuidPut($body, $uuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CartApi->cartItemsReplaceUuidPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CartApi;

my $api_instance = WWW::SwaggerClient::CartApi->new();
my $body = WWW::SwaggerClient::Object::Replace_uuid_body->new(); # Replace_uuid_body | 
my $uuid = uuid_example; # String | The uuid to be used by CM

eval { 
    my $result = $api_instance->cartItemsReplaceUuidPut(body => $body, uuid => $uuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CartApi->cartItemsReplaceUuidPut: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.CartApi()
body =  # Replace_uuid_body | 
uuid = uuid_example # String | The uuid to be used by CM

try: 
    # Replace an item from the cart
    api_response = api_instance.cart_items_replace_uuid_put(body, uuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CartApi->cartItemsReplaceUuidPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CartApi;

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

public class CartApiExample {

    public static void main(String[] args) {
        
        CartApi apiInstance = new CartApi();
        String uuid = uuid_example; // String | The uuid to be used by CM
        CartRevertLast_uuid_body body = ; // CartRevertLast_uuid_body | 
        try {
            executeActionResponse result = apiInstance.cartRevertLastUuidPut(uuid, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CartApi#cartRevertLastUuidPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CartApi;

public class CartApiExample {

    public static void main(String[] args) {
        CartApi apiInstance = new CartApi();
        String uuid = uuid_example; // String | The uuid to be used by CM
        CartRevertLast_uuid_body body = ; // CartRevertLast_uuid_body | 
        try {
            executeActionResponse result = apiInstance.cartRevertLastUuidPut(uuid, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CartApi#cartRevertLastUuidPut");
            e.printStackTrace();
        }
    }
}

String *uuid = uuid_example; // The uuid to be used by CM
CartRevertLast_uuid_body *body = ; //  (optional)

CartApi *apiInstance = [[CartApi alloc] init];

// Undo the last update on the cart
[apiInstance cartRevertLastUuidPutWith:uuid
    body:body
              completionHandler: ^(executeActionResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TokkioCartManager = require('tokkio_cart_manager');

var api = new TokkioCartManager.CartApi()
var uuid = uuid_example; // {{String}} The uuid to be used by CM
var opts = { 
  'body':  // {{CartRevertLast_uuid_body}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.cartRevertLastUuidPut(uuid, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new CartApi();
            var uuid = uuid_example;  // String | The uuid to be used by CM
            var body = new CartRevertLast_uuid_body(); // CartRevertLast_uuid_body |  (optional) 

            try
            {
                // Undo the last update on the cart
                executeActionResponse result = apiInstance.cartRevertLastUuidPut(uuid, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CartApi.cartRevertLastUuidPut: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCartApi();
$uuid = uuid_example; // String | The uuid to be used by CM
$body = ; // CartRevertLast_uuid_body | 

try {
    $result = $api_instance->cartRevertLastUuidPut($uuid, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CartApi->cartRevertLastUuidPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CartApi;

my $api_instance = WWW::SwaggerClient::CartApi->new();
my $uuid = uuid_example; # String | The uuid to be used by CM
my $body = WWW::SwaggerClient::Object::CartRevertLast_uuid_body->new(); # CartRevertLast_uuid_body | 

eval { 
    my $result = $api_instance->cartRevertLastUuidPut(uuid => $uuid, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CartApi->cartRevertLastUuidPut: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.CartApi()
uuid = uuid_example # String | The uuid to be used by CM
body =  # CartRevertLast_uuid_body |  (optional)

try: 
    # Undo the last update on the cart
    api_response = api_instance.cart_revert_last_uuid_put(uuid, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CartApi->cartRevertLastUuidPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CartApi;

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

public class CartApiExample {

    public static void main(String[] args) {
        
        CartApi apiInstance = new CartApi();
        Add_uuid_body_1 body = ; // Add_uuid_body_1 | 
        String uuid = uuid_example; // String | The uuid to be used by CM
        try {
            executeActionResponse result = apiInstance.cartToppingsAddUuidPut(body, uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CartApi#cartToppingsAddUuidPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CartApi;

public class CartApiExample {

    public static void main(String[] args) {
        CartApi apiInstance = new CartApi();
        Add_uuid_body_1 body = ; // Add_uuid_body_1 | 
        String uuid = uuid_example; // String | The uuid to be used by CM
        try {
            executeActionResponse result = apiInstance.cartToppingsAddUuidPut(body, uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CartApi#cartToppingsAddUuidPut");
            e.printStackTrace();
        }
    }
}

Add_uuid_body_1 *body = ; // 
String *uuid = uuid_example; // The uuid to be used by CM

CartApi *apiInstance = [[CartApi alloc] init];

// Add toppings items to the cart
[apiInstance cartToppingsAddUuidPutWith:body
    uuid:uuid
              completionHandler: ^(executeActionResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TokkioCartManager = require('tokkio_cart_manager');

var api = new TokkioCartManager.CartApi()
var body = ; // {{Add_uuid_body_1}} 
var uuid = uuid_example; // {{String}} The uuid to be used by CM

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new CartApi();
            var body = new Add_uuid_body_1(); // Add_uuid_body_1 | 
            var uuid = uuid_example;  // String | The uuid to be used by CM

            try
            {
                // Add toppings items to the cart
                executeActionResponse result = apiInstance.cartToppingsAddUuidPut(body, uuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CartApi.cartToppingsAddUuidPut: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCartApi();
$body = ; // Add_uuid_body_1 | 
$uuid = uuid_example; // String | The uuid to be used by CM

try {
    $result = $api_instance->cartToppingsAddUuidPut($body, $uuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CartApi->cartToppingsAddUuidPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CartApi;

my $api_instance = WWW::SwaggerClient::CartApi->new();
my $body = WWW::SwaggerClient::Object::Add_uuid_body_1->new(); # Add_uuid_body_1 | 
my $uuid = uuid_example; # String | The uuid to be used by CM

eval { 
    my $result = $api_instance->cartToppingsAddUuidPut(body => $body, uuid => $uuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CartApi->cartToppingsAddUuidPut: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.CartApi()
body =  # Add_uuid_body_1 | 
uuid = uuid_example # String | The uuid to be used by CM

try: 
    # Add toppings items to the cart
    api_response = api_instance.cart_toppings_add_uuid_put(body, uuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CartApi->cartToppingsAddUuidPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CartApi;

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

public class CartApiExample {

    public static void main(String[] args) {
        
        CartApi apiInstance = new CartApi();
        Remove_uuid_body body = ; // Remove_uuid_body | 
        String uuid = uuid_example; // String | The uuid to be used by CM
        try {
            executeActionResponse result = apiInstance.cartToppingsRemoveUuidPut(body, uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CartApi#cartToppingsRemoveUuidPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CartApi;

public class CartApiExample {

    public static void main(String[] args) {
        CartApi apiInstance = new CartApi();
        Remove_uuid_body body = ; // Remove_uuid_body | 
        String uuid = uuid_example; // String | The uuid to be used by CM
        try {
            executeActionResponse result = apiInstance.cartToppingsRemoveUuidPut(body, uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CartApi#cartToppingsRemoveUuidPut");
            e.printStackTrace();
        }
    }
}

Remove_uuid_body *body = ; // 
String *uuid = uuid_example; // The uuid to be used by CM

CartApi *apiInstance = [[CartApi alloc] init];

// Remove topping from an item in the cart
[apiInstance cartToppingsRemoveUuidPutWith:body
    uuid:uuid
              completionHandler: ^(executeActionResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TokkioCartManager = require('tokkio_cart_manager');

var api = new TokkioCartManager.CartApi()
var body = ; // {{Remove_uuid_body}} 
var uuid = uuid_example; // {{String}} The uuid to be used by CM

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new CartApi();
            var body = new Remove_uuid_body(); // Remove_uuid_body | 
            var uuid = uuid_example;  // String | The uuid to be used by CM

            try
            {
                // Remove topping from an item in the cart
                executeActionResponse result = apiInstance.cartToppingsRemoveUuidPut(body, uuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CartApi.cartToppingsRemoveUuidPut: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCartApi();
$body = ; // Remove_uuid_body | 
$uuid = uuid_example; // String | The uuid to be used by CM

try {
    $result = $api_instance->cartToppingsRemoveUuidPut($body, $uuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CartApi->cartToppingsRemoveUuidPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CartApi;

my $api_instance = WWW::SwaggerClient::CartApi->new();
my $body = WWW::SwaggerClient::Object::Remove_uuid_body->new(); # Remove_uuid_body | 
my $uuid = uuid_example; # String | The uuid to be used by CM

eval { 
    my $result = $api_instance->cartToppingsRemoveUuidPut(body => $body, uuid => $uuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CartApi->cartToppingsRemoveUuidPut: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.CartApi()
body =  # Remove_uuid_body | 
uuid = uuid_example # String | The uuid to be used by CM

try: 
    # Remove topping from an item in the cart
    api_response = api_instance.cart_toppings_remove_uuid_put(body, uuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CartApi->cartToppingsRemoveUuidPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CartApi;

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

public class CartApiExample {

    public static void main(String[] args) {
        
        CartApi apiInstance = new CartApi();
        Replace_uuid_body_1 body = ; // Replace_uuid_body_1 | 
        String uuid = uuid_example; // String | The uuid to be used by CM
        try {
            executeActionResponse result = apiInstance.cartToppingsReplaceUuidPut(body, uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CartApi#cartToppingsReplaceUuidPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CartApi;

public class CartApiExample {

    public static void main(String[] args) {
        CartApi apiInstance = new CartApi();
        Replace_uuid_body_1 body = ; // Replace_uuid_body_1 | 
        String uuid = uuid_example; // String | The uuid to be used by CM
        try {
            executeActionResponse result = apiInstance.cartToppingsReplaceUuidPut(body, uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CartApi#cartToppingsReplaceUuidPut");
            e.printStackTrace();
        }
    }
}

Replace_uuid_body_1 *body = ; // 
String *uuid = uuid_example; // The uuid to be used by CM

CartApi *apiInstance = [[CartApi alloc] init];

// Replace an item from the cart
[apiInstance cartToppingsReplaceUuidPutWith:body
    uuid:uuid
              completionHandler: ^(executeActionResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TokkioCartManager = require('tokkio_cart_manager');

var api = new TokkioCartManager.CartApi()
var body = ; // {{Replace_uuid_body_1}} 
var uuid = uuid_example; // {{String}} The uuid to be used by CM

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new CartApi();
            var body = new Replace_uuid_body_1(); // Replace_uuid_body_1 | 
            var uuid = uuid_example;  // String | The uuid to be used by CM

            try
            {
                // Replace an item from the cart
                executeActionResponse result = apiInstance.cartToppingsReplaceUuidPut(body, uuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CartApi.cartToppingsReplaceUuidPut: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCartApi();
$body = ; // Replace_uuid_body_1 | 
$uuid = uuid_example; // String | The uuid to be used by CM

try {
    $result = $api_instance->cartToppingsReplaceUuidPut($body, $uuid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CartApi->cartToppingsReplaceUuidPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CartApi;

my $api_instance = WWW::SwaggerClient::CartApi->new();
my $body = WWW::SwaggerClient::Object::Replace_uuid_body_1->new(); # Replace_uuid_body_1 | 
my $uuid = uuid_example; # String | The uuid to be used by CM

eval { 
    my $result = $api_instance->cartToppingsReplaceUuidPut(body => $body, uuid => $uuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CartApi->cartToppingsReplaceUuidPut: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.CartApi()
body =  # Replace_uuid_body_1 | 
uuid = uuid_example # String | The uuid to be used by CM

try: 
    # Replace an item from the cart
    api_response = api_instance.cart_toppings_replace_uuid_put(body, uuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CartApi->cartToppingsReplaceUuidPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CartApi;

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

public class CartApiExample {

    public static void main(String[] args) {
        
        CartApi apiInstance = new CartApi();
        String uuid = uuid_example; // String | The uuid to be used by CM
        try {
            inline_response_200_1 result = apiInstance.cartUuidDelete(uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CartApi#cartUuidDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CartApi;

public class CartApiExample {

    public static void main(String[] args) {
        CartApi apiInstance = new CartApi();
        String uuid = uuid_example; // String | The uuid to be used by CM
        try {
            inline_response_200_1 result = apiInstance.cartUuidDelete(uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CartApi#cartUuidDelete");
            e.printStackTrace();
        }
    }
}

String *uuid = uuid_example; // The uuid to be used by CM

CartApi *apiInstance = [[CartApi alloc] init];

// Remove all items from the cart
[apiInstance cartUuidDeleteWith:uuid
              completionHandler: ^(inline_response_200_1 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TokkioCartManager = require('tokkio_cart_manager');

var api = new TokkioCartManager.CartApi()
var uuid = uuid_example; // {{String}} The uuid to be used by CM

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new CartApi();
            var uuid = uuid_example;  // String | The uuid to be used by CM

            try
            {
                // Remove all items from the cart
                inline_response_200_1 result = apiInstance.cartUuidDelete(uuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CartApi.cartUuidDelete: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCartApi();
$uuid = uuid_example; // String | The uuid to be used by CM

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CartApi;

my $api_instance = WWW::SwaggerClient::CartApi->new();
my $uuid = uuid_example; # String | The uuid to be used by CM

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

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

# create an instance of the API class
api_instance = swagger_client.CartApi()
uuid = uuid_example # String | The uuid to be used by CM

try: 
    # Remove all items from the cart
    api_response = api_instance.cart_uuid_delete(uuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CartApi->cartUuidDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CartApi;

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

public class CartApiExample {

    public static void main(String[] args) {
        
        CartApi apiInstance = new CartApi();
        String uuid = uuid_example; // String | The uuid to be used by CM
        try {
            inline_response_200 result = apiInstance.cartUuidGet(uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CartApi#cartUuidGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CartApi;

public class CartApiExample {

    public static void main(String[] args) {
        CartApi apiInstance = new CartApi();
        String uuid = uuid_example; // String | The uuid to be used by CM
        try {
            inline_response_200 result = apiInstance.cartUuidGet(uuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CartApi#cartUuidGet");
            e.printStackTrace();
        }
    }
}

String *uuid = uuid_example; // The uuid to be used by CM

CartApi *apiInstance = [[CartApi alloc] init];

// Get list of items in cart
[apiInstance cartUuidGetWith:uuid
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TokkioCartManager = require('tokkio_cart_manager');

var api = new TokkioCartManager.CartApi()
var uuid = uuid_example; // {{String}} The uuid to be used by CM

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new CartApi();
            var uuid = uuid_example;  // String | The uuid to be used by CM

            try
            {
                // Get list of items in cart
                inline_response_200 result = apiInstance.cartUuidGet(uuid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CartApi.cartUuidGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiCartApi();
$uuid = uuid_example; // String | The uuid to be used by CM

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CartApi;

my $api_instance = WWW::SwaggerClient::CartApi->new();
my $uuid = uuid_example; # String | The uuid to be used by CM

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

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

# create an instance of the API class
api_instance = swagger_client.CartApi()
uuid = uuid_example # String | The uuid to be used by CM

try: 
    # Get list of items in cart
    api_response = api_instance.cart_uuid_get(uuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CartApi->cartUuidGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.StatusApi;

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

public class StatusApiExample {

    public static void main(String[] args) {
        
        StatusApi apiInstance = new StatusApi();
        try {
            apiInstance.statusGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling StatusApi#statusGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.StatusApi;

public class StatusApiExample {

    public static void main(String[] args) {
        StatusApi apiInstance = new StatusApi();
        try {
            apiInstance.statusGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling StatusApi#statusGet");
            e.printStackTrace();
        }
    }
}

StatusApi *apiInstance = [[StatusApi alloc] init];

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

var TokkioCartManager = require('tokkio_cart_manager');

var api = new TokkioCartManager.StatusApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.statusGet(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new StatusApi();

            try
            {
                // CM heartbeat
                apiInstance.statusGet();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling StatusApi.statusGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiStatusApi();

try {
    $api_instance->statusGet();
} catch (Exception $e) {
    echo 'Exception when calling StatusApi->statusGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::StatusApi;

my $api_instance = WWW::SwaggerClient::StatusApi->new();

eval { 
    $api_instance->statusGet();
};
if ($@) {
    warn "Exception when calling StatusApi->statusGet: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.StatusApi()

try: 
    # CM heartbeat
    api_instance.status_get()
except ApiException as e:
    print("Exception when calling StatusApi->statusGet: %s\n" % e)