Internal - TraceSense API

Api

apiAllergensListAllergensList

/api/allergens/list-allergens/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/allergens/list-allergens/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        try {
            array[Allergens] result = apiInstance.apiAllergensListAllergensList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiAllergensListAllergensList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            array[Allergens] result = apiInstance.apiAllergensListAllergensList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiAllergensListAllergensList");
            e.printStackTrace();
        }
    }
}

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


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

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

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

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

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

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

            var apiInstance = new ApiApi();

            try
            {
                array[Allergens] result = apiInstance.apiAllergensListAllergensList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiAllergensListAllergensList: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.api_allergens_list_allergens_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiAllergensListAllergensList: %s\n" % e)

Parameters

Responses

Status: 200 -

Schema

apiCommoditiesAddCsvCreate

Checks relevant directory and inserts data into database

/api/commodities/add/csv/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/commodities/add/csv/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiCommoditiesAddCsvCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesAddCsvCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

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

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


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

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

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

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

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

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

            var apiInstance = new ApiApi();

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

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.api_commodities_add_csv_create()
except ApiException as e:
    print("Exception when calling ApiApi->apiCommoditiesAddCsvCreate: %s\n" % e)

Parameters

Responses

Status: 201 -

apiCommoditiesCommoditiesCreate

/api/commodities/commodities/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/commodities/commodities/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        Commodities data = ; // Commodities | 
        try {
            Commodities result = apiInstance.apiCommoditiesCommoditiesCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesCommoditiesCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Commodities data = ; // Commodities | 
        try {
            Commodities result = apiInstance.apiCommoditiesCommoditiesCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesCommoditiesCreate");
            e.printStackTrace();
        }
    }
}

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

Commodities *data = ; // 

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

[apiInstance apiCommoditiesCommoditiesCreateWith:data
              completionHandler: ^(Commodities output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var data = ; // {Commodities} 


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

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

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

            var apiInstance = new ApiApi();
            var data = new Commodities(); // Commodities | 

            try
            {
                Commodities result = apiInstance.apiCommoditiesCommoditiesCreate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiCommoditiesCommoditiesCreate: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$data = ; // Commodities | 

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $data = WWW::SwaggerClient::Object::Commodities->new(); # Commodities | 

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
data =  # Commodities | 

try: 
    api_response = api_instance.api_commodities_commodities_create(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiCommoditiesCommoditiesCreate: %s\n" % e)

Parameters

Body parameters

Name	Description
data *

Responses

Status: 201 -

Schema

apiCommoditiesCommoditiesList

/api/commodities/commodities/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/commodities/commodities/?page="

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        Integer page = 56; // Integer | A page number within the paginated result set.
        try {
            inline_response_200 result = apiInstance.apiCommoditiesCommoditiesList(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesCommoditiesList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Integer page = 56; // Integer | A page number within the paginated result set.
        try {
            inline_response_200 result = apiInstance.apiCommoditiesCommoditiesList(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesCommoditiesList");
            e.printStackTrace();
        }
    }
}

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

Integer *page = 56; // A page number within the paginated result set. (optional)

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

[apiInstance apiCommoditiesCommoditiesListWith:page
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var opts = { 
  'page': 56 // {Integer} A page number within the paginated result set.
};

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

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

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

            var apiInstance = new ApiApi();
            var page = 56;  // Integer | A page number within the paginated result set. (optional) 

            try
            {
                inline_response_200 result = apiInstance.apiCommoditiesCommoditiesList(page);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiCommoditiesCommoditiesList: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$page = 56; // Integer | A page number within the paginated result set.

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $page = 56; # Integer | A page number within the paginated result set.

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
page = 56 # Integer | A page number within the paginated result set. (optional)

try: 
    api_response = api_instance.api_commodities_commodities_list(page=page)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiCommoditiesCommoditiesList: %s\n" % e)

Parameters

Query parameters

Name	Description
page	Integer A page number within the paginated result set.

Responses

Status: 200 -

Schema

apiCommoditiesListCommodityGroupsList

/api/commodities/list/commodity/groups/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/commodities/list/commodity/groups/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        try {
            array[CommodityGroups] result = apiInstance.apiCommoditiesListCommodityGroupsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesListCommodityGroupsList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            array[CommodityGroups] result = apiInstance.apiCommoditiesListCommodityGroupsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesListCommodityGroupsList");
            e.printStackTrace();
        }
    }
}

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


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

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

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

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

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

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

            var apiInstance = new ApiApi();

            try
            {
                array[CommodityGroups] result = apiInstance.apiCommoditiesListCommodityGroupsList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiCommoditiesListCommodityGroupsList: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.api_commodities_list_commodity_groups_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiCommoditiesListCommodityGroupsList: %s\n" % e)

Parameters

Responses

Status: 200 -

Schema

apiCommoditiesListList

/api/commodities/list/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/commodities/list/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        try {
            array[Commodities] result = apiInstance.apiCommoditiesListList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesListList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            array[Commodities] result = apiInstance.apiCommoditiesListList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesListList");
            e.printStackTrace();
        }
    }
}

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


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

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

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

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

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

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

            var apiInstance = new ApiApi();

            try
            {
                array[Commodities] result = apiInstance.apiCommoditiesListList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiCommoditiesListList: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.api_commodities_list_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiCommoditiesListList: %s\n" % e)

Parameters

Responses

Status: 200 -

Schema

apiCommoditiesListSuppliersList

/api/commodities/list/suppliers/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/commodities/list/suppliers/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        try {
            array[Suppliers] result = apiInstance.apiCommoditiesListSuppliersList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesListSuppliersList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            array[Suppliers] result = apiInstance.apiCommoditiesListSuppliersList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesListSuppliersList");
            e.printStackTrace();
        }
    }
}

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


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

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

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

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

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

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

            var apiInstance = new ApiApi();

            try
            {
                array[Suppliers] result = apiInstance.apiCommoditiesListSuppliersList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiCommoditiesListSuppliersList: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.api_commodities_list_suppliers_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiCommoditiesListSuppliersList: %s\n" % e)

Parameters

Responses

Status: 200 -

Schema

apiCommoditiesSupplierAddCsvCreate

Checks relevant directory and inserts data into database

/api/commodities/supplier/add/csv/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/commodities/supplier/add/csv/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiCommoditiesSupplierAddCsvCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesSupplierAddCsvCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

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

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


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

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

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

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

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

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

            var apiInstance = new ApiApi();

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

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.api_commodities_supplier_add_csv_create()
except ApiException as e:
    print("Exception when calling ApiApi->apiCommoditiesSupplierAddCsvCreate: %s\n" % e)

Parameters

Responses

Status: 201 -

apiCommoditiesSupplierCreate

/api/commodities/supplier/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/commodities/supplier/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        Suppliers data = ; // Suppliers | 
        try {
            Suppliers result = apiInstance.apiCommoditiesSupplierCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesSupplierCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Suppliers data = ; // Suppliers | 
        try {
            Suppliers result = apiInstance.apiCommoditiesSupplierCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesSupplierCreate");
            e.printStackTrace();
        }
    }
}

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

Suppliers *data = ; // 

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

[apiInstance apiCommoditiesSupplierCreateWith:data
              completionHandler: ^(Suppliers output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var data = ; // {Suppliers} 


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

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

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

            var apiInstance = new ApiApi();
            var data = new Suppliers(); // Suppliers | 

            try
            {
                Suppliers result = apiInstance.apiCommoditiesSupplierCreate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiCommoditiesSupplierCreate: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$data = ; // Suppliers | 

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $data = WWW::SwaggerClient::Object::Suppliers->new(); # Suppliers | 

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
data =  # Suppliers | 

try: 
    api_response = api_instance.api_commodities_supplier_create(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiCommoditiesSupplierCreate: %s\n" % e)

Parameters

Body parameters

Name	Description
data *

Responses

Status: 201 -

Schema

apiCommoditiesSupplierList

/api/commodities/supplier/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/commodities/supplier/?page="

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        Integer page = 56; // Integer | A page number within the paginated result set.
        try {
            inline_response_200_1 result = apiInstance.apiCommoditiesSupplierList(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesSupplierList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Integer page = 56; // Integer | A page number within the paginated result set.
        try {
            inline_response_200_1 result = apiInstance.apiCommoditiesSupplierList(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesSupplierList");
            e.printStackTrace();
        }
    }
}

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

Integer *page = 56; // A page number within the paginated result set. (optional)

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

[apiInstance apiCommoditiesSupplierListWith:page
              completionHandler: ^(inline_response_200_1 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var opts = { 
  'page': 56 // {Integer} A page number within the paginated result set.
};

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

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

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

            var apiInstance = new ApiApi();
            var page = 56;  // Integer | A page number within the paginated result set. (optional) 

            try
            {
                inline_response_200_1 result = apiInstance.apiCommoditiesSupplierList(page);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiCommoditiesSupplierList: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$page = 56; // Integer | A page number within the paginated result set.

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $page = 56; # Integer | A page number within the paginated result set.

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
page = 56 # Integer | A page number within the paginated result set. (optional)

try: 
    api_response = api_instance.api_commodities_supplier_list(page=page)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiCommoditiesSupplierList: %s\n" % e)

Parameters

Query parameters

Name	Description
page	Integer A page number within the paginated result set.

Responses

Status: 200 -

Schema

apiDispatchListCustomersList

/api/dispatch/list/customers/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/dispatch/list/customers/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        try {
            array[Customers] result = apiInstance.apiDispatchListCustomersList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiDispatchListCustomersList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            array[Customers] result = apiInstance.apiDispatchListCustomersList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiDispatchListCustomersList");
            e.printStackTrace();
        }
    }
}

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


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

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

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

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

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

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

            var apiInstance = new ApiApi();

            try
            {
                array[Customers] result = apiInstance.apiDispatchListCustomersList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiDispatchListCustomersList: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.api_dispatch_list_customers_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiDispatchListCustomersList: %s\n" % e)

Parameters

Responses

Status: 200 -

Schema

apiDispatchListSalesOrdersList

/api/dispatch/list/sales/orders/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/dispatch/list/sales/orders/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        try {
            array[SalesOrderHeader] result = apiInstance.apiDispatchListSalesOrdersList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiDispatchListSalesOrdersList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            array[SalesOrderHeader] result = apiInstance.apiDispatchListSalesOrdersList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiDispatchListSalesOrdersList");
            e.printStackTrace();
        }
    }
}

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


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

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

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

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

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

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

            var apiInstance = new ApiApi();

            try
            {
                array[SalesOrderHeader] result = apiInstance.apiDispatchListSalesOrdersList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiDispatchListSalesOrdersList: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.api_dispatch_list_sales_orders_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiDispatchListSalesOrdersList: %s\n" % e)

Parameters

Responses

Status: 200 -

Schema

apiDispatchSalesOrderDetailsList

/api/dispatch/sales/order/details/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/dispatch/sales/order/details/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        try {
            array[SalesOrderDetail] result = apiInstance.apiDispatchSalesOrderDetailsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiDispatchSalesOrderDetailsList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            array[SalesOrderDetail] result = apiInstance.apiDispatchSalesOrderDetailsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiDispatchSalesOrderDetailsList");
            e.printStackTrace();
        }
    }
}

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


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

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

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

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

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

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

            var apiInstance = new ApiApi();

            try
            {
                array[SalesOrderDetail] result = apiInstance.apiDispatchSalesOrderDetailsList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiDispatchSalesOrderDetailsList: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.api_dispatch_sales_order_details_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiDispatchSalesOrderDetailsList: %s\n" % e)

Parameters

Responses

Status: 200 -

Schema

apiDispatchV1SalesordersCreate

Checks relevant directory and inserts data into database

/api/dispatch/v1/salesorders/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/dispatch/v1/salesorders/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiDispatchV1SalesordersCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiDispatchV1SalesordersCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

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

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


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

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

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

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

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

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

            var apiInstance = new ApiApi();

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

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.api_dispatch_v1_salesorders_create()
except ApiException as e:
    print("Exception when calling ApiApi->apiDispatchV1SalesordersCreate: %s\n" % e)

Parameters

Responses

Status: 201 -

apiDocumentsUploadCreate

/api/documents/upload/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/documents/upload/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiDocumentsUploadCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiDocumentsUploadCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

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

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


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

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

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

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

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

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

            var apiInstance = new ApiApi();

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

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.api_documents_upload_create()
except ApiException as e:
    print("Exception when calling ApiApi->apiDocumentsUploadCreate: %s\n" % e)

Parameters

Responses

Status: 201 -

apiJobListHeadersList

/api/job/list/headers/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/job/list/headers/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        try {
            array[JobHeader] result = apiInstance.apiJobListHeadersList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiJobListHeadersList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            array[JobHeader] result = apiInstance.apiJobListHeadersList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiJobListHeadersList");
            e.printStackTrace();
        }
    }
}

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


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

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

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

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

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

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

            var apiInstance = new ApiApi();

            try
            {
                array[JobHeader] result = apiInstance.apiJobListHeadersList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiJobListHeadersList: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.api_job_list_headers_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiJobListHeadersList: %s\n" % e)

Parameters

Responses

Status: 200 -

Schema

apiMaintenancesPlannedTasksCreate

/api/maintenances/planned-tasks/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/planned-tasks/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        PlannedTaskCreate data = ; // PlannedTaskCreate | 
        try {
            PlannedTaskCreate result = apiInstance.apiMaintenancesPlannedTasksCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesPlannedTasksCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        PlannedTaskCreate data = ; // PlannedTaskCreate | 
        try {
            PlannedTaskCreate result = apiInstance.apiMaintenancesPlannedTasksCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesPlannedTasksCreate");
            e.printStackTrace();
        }
    }
}

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

PlannedTaskCreate *data = ; // 

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

[apiInstance apiMaintenancesPlannedTasksCreateWith:data
              completionHandler: ^(PlannedTaskCreate output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var data = ; // {PlannedTaskCreate} 


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

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

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

            var apiInstance = new ApiApi();
            var data = new PlannedTaskCreate(); // PlannedTaskCreate | 

            try
            {
                PlannedTaskCreate result = apiInstance.apiMaintenancesPlannedTasksCreate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesPlannedTasksCreate: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$data = ; // PlannedTaskCreate | 

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $data = WWW::SwaggerClient::Object::PlannedTaskCreate->new(); # PlannedTaskCreate | 

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
data =  # PlannedTaskCreate | 

try: 
    api_response = api_instance.api_maintenances_planned_tasks_create(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesPlannedTasksCreate: %s\n" % e)

Parameters

Body parameters

Name	Description
data *

Responses

Status: 201 -

Schema

apiMaintenancesPlannedTasksDelete

/api/maintenances/planned-tasks/{id}/

Usage and SDK Samples

curl -X DELETE -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/planned-tasks/{id}/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiMaintenancesPlannedTasksDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesPlannedTasksDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiMaintenancesPlannedTasksDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesPlannedTasksDelete");
            e.printStackTrace();
        }
    }
}

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

String *id = id_example; // 

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

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

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 


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

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

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

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 

            try
            {
                apiInstance.apiMaintenancesPlannedTasksDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesPlannedTasksDelete: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->apiMaintenancesPlannedTasksDelete(id => $id);
};
if ($@) {
    warn "Exception when calling ApiApi->apiMaintenancesPlannedTasksDelete: $@\n";
}

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 

try: 
    api_instance.api_maintenances_planned_tasks_delete(id)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesPlannedTasksDelete: %s\n" % e)

Parameters

Path parameters

Name	Description
id*	String Required

Responses

Status: 204 -

apiMaintenancesPlannedTasksList

/api/maintenances/planned-tasks/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/planned-tasks/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        try {
            array[PlannedTask] result = apiInstance.apiMaintenancesPlannedTasksList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesPlannedTasksList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            array[PlannedTask] result = apiInstance.apiMaintenancesPlannedTasksList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesPlannedTasksList");
            e.printStackTrace();
        }
    }
}

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


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

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

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

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

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

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

            var apiInstance = new ApiApi();

            try
            {
                array[PlannedTask] result = apiInstance.apiMaintenancesPlannedTasksList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesPlannedTasksList: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.api_maintenances_planned_tasks_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesPlannedTasksList: %s\n" % e)

Parameters

Responses

Status: 200 -

Schema

apiMaintenancesPlannedTasksPartialUpdate

/api/maintenances/planned-tasks/{id}/

Usage and SDK Samples

curl -X PATCH -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/planned-tasks/{id}/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        PlannedTaskCreate data = ; // PlannedTaskCreate | 
        try {
            PlannedTaskCreate result = apiInstance.apiMaintenancesPlannedTasksPartialUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesPlannedTasksPartialUpdate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        PlannedTaskCreate data = ; // PlannedTaskCreate | 
        try {
            PlannedTaskCreate result = apiInstance.apiMaintenancesPlannedTasksPartialUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesPlannedTasksPartialUpdate");
            e.printStackTrace();
        }
    }
}

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

String *id = id_example; // 
PlannedTaskCreate *data = ; // 

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

[apiInstance apiMaintenancesPlannedTasksPartialUpdateWith:id
    data:data
              completionHandler: ^(PlannedTaskCreate output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 

var data = ; // {PlannedTaskCreate} 


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

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

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

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 
            var data = new PlannedTaskCreate(); // PlannedTaskCreate | 

            try
            {
                PlannedTaskCreate result = apiInstance.apiMaintenancesPlannedTasksPartialUpdate(id, data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesPlannedTasksPartialUpdate: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 
$data = ; // PlannedTaskCreate | 

try {
    $result = $api_instance->apiMaintenancesPlannedTasksPartialUpdate($id, $data);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiMaintenancesPlannedTasksPartialUpdate: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 
my $data = WWW::SwaggerClient::Object::PlannedTaskCreate->new(); # PlannedTaskCreate | 

eval { 
    my $result = $api_instance->apiMaintenancesPlannedTasksPartialUpdate(id => $id, data => $data);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiApi->apiMaintenancesPlannedTasksPartialUpdate: $@\n";
}

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 
data =  # PlannedTaskCreate | 

try: 
    api_response = api_instance.api_maintenances_planned_tasks_partial_update(id, data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesPlannedTasksPartialUpdate: %s\n" % e)

Parameters

Path parameters

Name	Description
id*	String Required

Body parameters

Name	Description
data *

Responses

Status: 200 -

Schema

apiMaintenancesPlannedTasksRead

/api/maintenances/planned-tasks/{id}/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/planned-tasks/{id}/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            PlannedTask result = apiInstance.apiMaintenancesPlannedTasksRead(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesPlannedTasksRead");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            PlannedTask result = apiInstance.apiMaintenancesPlannedTasksRead(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesPlannedTasksRead");
            e.printStackTrace();
        }
    }
}

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

String *id = id_example; // 

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

[apiInstance apiMaintenancesPlannedTasksReadWith:id
              completionHandler: ^(PlannedTask output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 


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

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

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

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 

            try
            {
                PlannedTask result = apiInstance.apiMaintenancesPlannedTasksRead(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesPlannedTasksRead: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 

try: 
    api_response = api_instance.api_maintenances_planned_tasks_read(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesPlannedTasksRead: %s\n" % e)

Parameters

Path parameters

Name	Description
id*	String Required

Responses

Status: 200 -

Schema

apiMaintenancesPlannedTasksUpdate

/api/maintenances/planned-tasks/{id}/

Usage and SDK Samples

curl -X PUT -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/planned-tasks/{id}/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        PlannedTaskCreate data = ; // PlannedTaskCreate | 
        try {
            PlannedTaskCreate result = apiInstance.apiMaintenancesPlannedTasksUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesPlannedTasksUpdate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        PlannedTaskCreate data = ; // PlannedTaskCreate | 
        try {
            PlannedTaskCreate result = apiInstance.apiMaintenancesPlannedTasksUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesPlannedTasksUpdate");
            e.printStackTrace();
        }
    }
}

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

String *id = id_example; // 
PlannedTaskCreate *data = ; // 

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

[apiInstance apiMaintenancesPlannedTasksUpdateWith:id
    data:data
              completionHandler: ^(PlannedTaskCreate output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 

var data = ; // {PlannedTaskCreate} 


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

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

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

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 
            var data = new PlannedTaskCreate(); // PlannedTaskCreate | 

            try
            {
                PlannedTaskCreate result = apiInstance.apiMaintenancesPlannedTasksUpdate(id, data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesPlannedTasksUpdate: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 
$data = ; // PlannedTaskCreate | 

try {
    $result = $api_instance->apiMaintenancesPlannedTasksUpdate($id, $data);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiMaintenancesPlannedTasksUpdate: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 
my $data = WWW::SwaggerClient::Object::PlannedTaskCreate->new(); # PlannedTaskCreate | 

eval { 
    my $result = $api_instance->apiMaintenancesPlannedTasksUpdate(id => $id, data => $data);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiApi->apiMaintenancesPlannedTasksUpdate: $@\n";
}

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 
data =  # PlannedTaskCreate | 

try: 
    api_response = api_instance.api_maintenances_planned_tasks_update(id, data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesPlannedTasksUpdate: %s\n" % e)

Parameters

Path parameters

Name	Description
id*	String Required

Body parameters

Name	Description
data *

Responses

Status: 200 -

Schema

apiMaintenancesSchedulesCreate

/api/maintenances/schedules/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/schedules/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        Schedule data = ; // Schedule | 
        try {
            Schedule result = apiInstance.apiMaintenancesSchedulesCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesSchedulesCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Schedule data = ; // Schedule | 
        try {
            Schedule result = apiInstance.apiMaintenancesSchedulesCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesSchedulesCreate");
            e.printStackTrace();
        }
    }
}

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

Schedule *data = ; // 

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

[apiInstance apiMaintenancesSchedulesCreateWith:data
              completionHandler: ^(Schedule output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var data = ; // {Schedule} 


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

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

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

            var apiInstance = new ApiApi();
            var data = new Schedule(); // Schedule | 

            try
            {
                Schedule result = apiInstance.apiMaintenancesSchedulesCreate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesSchedulesCreate: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$data = ; // Schedule | 

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $data = WWW::SwaggerClient::Object::Schedule->new(); # Schedule | 

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
data =  # Schedule | 

try: 
    api_response = api_instance.api_maintenances_schedules_create(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesSchedulesCreate: %s\n" % e)

Parameters

Body parameters

Name	Description
data *

Responses

Status: 201 -

Schema

apiMaintenancesSchedulesDelete

/api/maintenances/schedules/{id}/

Usage and SDK Samples

curl -X DELETE -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/schedules/{id}/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiMaintenancesSchedulesDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesSchedulesDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiMaintenancesSchedulesDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesSchedulesDelete");
            e.printStackTrace();
        }
    }
}

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

String *id = id_example; // 

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

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

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 


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

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

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

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 

            try
            {
                apiInstance.apiMaintenancesSchedulesDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesSchedulesDelete: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->apiMaintenancesSchedulesDelete(id => $id);
};
if ($@) {
    warn "Exception when calling ApiApi->apiMaintenancesSchedulesDelete: $@\n";
}

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 

try: 
    api_instance.api_maintenances_schedules_delete(id)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesSchedulesDelete: %s\n" % e)

Parameters

Path parameters

Name	Description
id*	String Required

Responses

Status: 204 -

apiMaintenancesSchedulesList

/api/maintenances/schedules/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/schedules/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        try {
            array[Schedule] result = apiInstance.apiMaintenancesSchedulesList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesSchedulesList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            array[Schedule] result = apiInstance.apiMaintenancesSchedulesList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesSchedulesList");
            e.printStackTrace();
        }
    }
}

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


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

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

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

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

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

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

            var apiInstance = new ApiApi();

            try
            {
                array[Schedule] result = apiInstance.apiMaintenancesSchedulesList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesSchedulesList: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.api_maintenances_schedules_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesSchedulesList: %s\n" % e)

Parameters

Responses

Status: 200 -

Schema

apiMaintenancesSchedulesPartialUpdate

/api/maintenances/schedules/{id}/

Usage and SDK Samples

curl -X PATCH -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/schedules/{id}/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        Schedule data = ; // Schedule | 
        try {
            Schedule result = apiInstance.apiMaintenancesSchedulesPartialUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesSchedulesPartialUpdate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        Schedule data = ; // Schedule | 
        try {
            Schedule result = apiInstance.apiMaintenancesSchedulesPartialUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesSchedulesPartialUpdate");
            e.printStackTrace();
        }
    }
}

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

String *id = id_example; // 
Schedule *data = ; // 

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

[apiInstance apiMaintenancesSchedulesPartialUpdateWith:id
    data:data
              completionHandler: ^(Schedule output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 

var data = ; // {Schedule} 


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

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

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

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 
            var data = new Schedule(); // Schedule | 

            try
            {
                Schedule result = apiInstance.apiMaintenancesSchedulesPartialUpdate(id, data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesSchedulesPartialUpdate: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 
$data = ; // Schedule | 

try {
    $result = $api_instance->apiMaintenancesSchedulesPartialUpdate($id, $data);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiMaintenancesSchedulesPartialUpdate: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 
my $data = WWW::SwaggerClient::Object::Schedule->new(); # Schedule | 

eval { 
    my $result = $api_instance->apiMaintenancesSchedulesPartialUpdate(id => $id, data => $data);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiApi->apiMaintenancesSchedulesPartialUpdate: $@\n";
}

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 
data =  # Schedule | 

try: 
    api_response = api_instance.api_maintenances_schedules_partial_update(id, data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesSchedulesPartialUpdate: %s\n" % e)

Parameters

Path parameters

Name	Description
id*	String Required

Body parameters

Name	Description
data *

Responses

Status: 200 -

Schema

apiMaintenancesSchedulesRead

/api/maintenances/schedules/{id}/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/schedules/{id}/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            Schedule result = apiInstance.apiMaintenancesSchedulesRead(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesSchedulesRead");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            Schedule result = apiInstance.apiMaintenancesSchedulesRead(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesSchedulesRead");
            e.printStackTrace();
        }
    }
}

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

String *id = id_example; // 

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

[apiInstance apiMaintenancesSchedulesReadWith:id
              completionHandler: ^(Schedule output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 


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

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

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

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 

            try
            {
                Schedule result = apiInstance.apiMaintenancesSchedulesRead(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesSchedulesRead: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 

try: 
    api_response = api_instance.api_maintenances_schedules_read(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesSchedulesRead: %s\n" % e)

Parameters

Path parameters

Name	Description
id*	String Required

Responses

Status: 200 -

Schema

apiMaintenancesSchedulesUpdate

/api/maintenances/schedules/{id}/

Usage and SDK Samples

curl -X PUT -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/schedules/{id}/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        Schedule data = ; // Schedule | 
        try {
            Schedule result = apiInstance.apiMaintenancesSchedulesUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesSchedulesUpdate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        Schedule data = ; // Schedule | 
        try {
            Schedule result = apiInstance.apiMaintenancesSchedulesUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesSchedulesUpdate");
            e.printStackTrace();
        }
    }
}

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

String *id = id_example; // 
Schedule *data = ; // 

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

[apiInstance apiMaintenancesSchedulesUpdateWith:id
    data:data
              completionHandler: ^(Schedule output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 

var data = ; // {Schedule} 


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

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

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

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 
            var data = new Schedule(); // Schedule | 

            try
            {
                Schedule result = apiInstance.apiMaintenancesSchedulesUpdate(id, data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesSchedulesUpdate: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 
$data = ; // Schedule | 

try {
    $result = $api_instance->apiMaintenancesSchedulesUpdate($id, $data);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiMaintenancesSchedulesUpdate: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 
my $data = WWW::SwaggerClient::Object::Schedule->new(); # Schedule | 

eval { 
    my $result = $api_instance->apiMaintenancesSchedulesUpdate(id => $id, data => $data);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiApi->apiMaintenancesSchedulesUpdate: $@\n";
}

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 
data =  # Schedule | 

try: 
    api_response = api_instance.api_maintenances_schedules_update(id, data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesSchedulesUpdate: %s\n" % e)

Parameters

Path parameters

Name	Description
id*	String Required

Body parameters

Name	Description
data *

Responses

Status: 200 -

Schema

apiMaintenancesTaskColorsCreate

/api/maintenances/task-colors/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/task-colors/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiMaintenancesTaskColorsCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesTaskColorsCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

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

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


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

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

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

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

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

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

            var apiInstance = new ApiApi();

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

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.api_maintenances_task_colors_create()
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesTaskColorsCreate: %s\n" % e)

Parameters

Responses

Status: 201 -

apiMaintenancesTaskColorsList

/api/maintenances/task-colors/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/task-colors/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiMaintenancesTaskColorsList();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesTaskColorsList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

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

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


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

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

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

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

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

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

            var apiInstance = new ApiApi();

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

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.api_maintenances_task_colors_list()
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesTaskColorsList: %s\n" % e)

Parameters

Responses

Status: 200 -

apiMaintenancesUnplannedTasksCreate

/api/maintenances/unplanned-tasks/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/unplanned-tasks/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        UnplannedTask data = ; // UnplannedTask | 
        try {
            UnplannedTask result = apiInstance.apiMaintenancesUnplannedTasksCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesUnplannedTasksCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        UnplannedTask data = ; // UnplannedTask | 
        try {
            UnplannedTask result = apiInstance.apiMaintenancesUnplannedTasksCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesUnplannedTasksCreate");
            e.printStackTrace();
        }
    }
}

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

UnplannedTask *data = ; // 

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

[apiInstance apiMaintenancesUnplannedTasksCreateWith:data
              completionHandler: ^(UnplannedTask output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var data = ; // {UnplannedTask} 


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

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

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

            var apiInstance = new ApiApi();
            var data = new UnplannedTask(); // UnplannedTask | 

            try
            {
                UnplannedTask result = apiInstance.apiMaintenancesUnplannedTasksCreate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesUnplannedTasksCreate: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$data = ; // UnplannedTask | 

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $data = WWW::SwaggerClient::Object::UnplannedTask->new(); # UnplannedTask | 

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
data =  # UnplannedTask | 

try: 
    api_response = api_instance.api_maintenances_unplanned_tasks_create(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesUnplannedTasksCreate: %s\n" % e)

Parameters

Body parameters

Name	Description
data *

Responses

Status: 201 -

Schema

apiMaintenancesUnplannedTasksDelete

/api/maintenances/unplanned-tasks/{id}/

Usage and SDK Samples

curl -X DELETE -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/unplanned-tasks/{id}/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiMaintenancesUnplannedTasksDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesUnplannedTasksDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiMaintenancesUnplannedTasksDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesUnplannedTasksDelete");
            e.printStackTrace();
        }
    }
}

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

String *id = id_example; // 

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

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

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 


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

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

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

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 

            try
            {
                apiInstance.apiMaintenancesUnplannedTasksDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesUnplannedTasksDelete: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->apiMaintenancesUnplannedTasksDelete(id => $id);
};
if ($@) {
    warn "Exception when calling ApiApi->apiMaintenancesUnplannedTasksDelete: $@\n";
}

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 

try: 
    api_instance.api_maintenances_unplanned_tasks_delete(id)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesUnplannedTasksDelete: %s\n" % e)

Parameters

Path parameters

Name	Description
id*	String Required

Responses

Status: 204 -

apiMaintenancesUnplannedTasksList

/api/maintenances/unplanned-tasks/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/unplanned-tasks/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        try {
            array[UnplannedTask] result = apiInstance.apiMaintenancesUnplannedTasksList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesUnplannedTasksList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            array[UnplannedTask] result = apiInstance.apiMaintenancesUnplannedTasksList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesUnplannedTasksList");
            e.printStackTrace();
        }
    }
}

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


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

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

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

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

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

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

            var apiInstance = new ApiApi();

            try
            {
                array[UnplannedTask] result = apiInstance.apiMaintenancesUnplannedTasksList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesUnplannedTasksList: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.api_maintenances_unplanned_tasks_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesUnplannedTasksList: %s\n" % e)

Parameters

Responses

Status: 200 -

Schema

apiMaintenancesUnplannedTasksPartialUpdate

/api/maintenances/unplanned-tasks/{id}/

Usage and SDK Samples

curl -X PATCH -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/unplanned-tasks/{id}/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        UnplannedTask data = ; // UnplannedTask | 
        try {
            UnplannedTask result = apiInstance.apiMaintenancesUnplannedTasksPartialUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesUnplannedTasksPartialUpdate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        UnplannedTask data = ; // UnplannedTask | 
        try {
            UnplannedTask result = apiInstance.apiMaintenancesUnplannedTasksPartialUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesUnplannedTasksPartialUpdate");
            e.printStackTrace();
        }
    }
}

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

String *id = id_example; // 
UnplannedTask *data = ; // 

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

[apiInstance apiMaintenancesUnplannedTasksPartialUpdateWith:id
    data:data
              completionHandler: ^(UnplannedTask output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 

var data = ; // {UnplannedTask} 


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

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

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

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 
            var data = new UnplannedTask(); // UnplannedTask | 

            try
            {
                UnplannedTask result = apiInstance.apiMaintenancesUnplannedTasksPartialUpdate(id, data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesUnplannedTasksPartialUpdate: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 
$data = ; // UnplannedTask | 

try {
    $result = $api_instance->apiMaintenancesUnplannedTasksPartialUpdate($id, $data);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiMaintenancesUnplannedTasksPartialUpdate: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 
my $data = WWW::SwaggerClient::Object::UnplannedTask->new(); # UnplannedTask | 

eval { 
    my $result = $api_instance->apiMaintenancesUnplannedTasksPartialUpdate(id => $id, data => $data);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiApi->apiMaintenancesUnplannedTasksPartialUpdate: $@\n";
}

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 
data =  # UnplannedTask | 

try: 
    api_response = api_instance.api_maintenances_unplanned_tasks_partial_update(id, data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesUnplannedTasksPartialUpdate: %s\n" % e)

Parameters

Path parameters

Name	Description
id*	String Required

Body parameters

Name	Description
data *

Responses

Status: 200 -

Schema

apiMaintenancesUnplannedTasksRead

/api/maintenances/unplanned-tasks/{id}/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/unplanned-tasks/{id}/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            UnplannedTask result = apiInstance.apiMaintenancesUnplannedTasksRead(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesUnplannedTasksRead");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            UnplannedTask result = apiInstance.apiMaintenancesUnplannedTasksRead(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesUnplannedTasksRead");
            e.printStackTrace();
        }
    }
}

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

String *id = id_example; // 

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

[apiInstance apiMaintenancesUnplannedTasksReadWith:id
              completionHandler: ^(UnplannedTask output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 


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

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

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

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 

            try
            {
                UnplannedTask result = apiInstance.apiMaintenancesUnplannedTasksRead(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesUnplannedTasksRead: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 

try: 
    api_response = api_instance.api_maintenances_unplanned_tasks_read(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesUnplannedTasksRead: %s\n" % e)

Parameters

Path parameters

Name	Description
id*	String Required

Responses

Status: 200 -

Schema

apiMaintenancesUnplannedTasksUpdate

/api/maintenances/unplanned-tasks/{id}/

Usage and SDK Samples

curl -X PUT -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/unplanned-tasks/{id}/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        UnplannedTask data = ; // UnplannedTask | 
        try {
            UnplannedTask result = apiInstance.apiMaintenancesUnplannedTasksUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesUnplannedTasksUpdate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        UnplannedTask data = ; // UnplannedTask | 
        try {
            UnplannedTask result = apiInstance.apiMaintenancesUnplannedTasksUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesUnplannedTasksUpdate");
            e.printStackTrace();
        }
    }
}

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

String *id = id_example; // 
UnplannedTask *data = ; // 

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

[apiInstance apiMaintenancesUnplannedTasksUpdateWith:id
    data:data
              completionHandler: ^(UnplannedTask output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 

var data = ; // {UnplannedTask} 


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

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

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

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 
            var data = new UnplannedTask(); // UnplannedTask | 

            try
            {
                UnplannedTask result = apiInstance.apiMaintenancesUnplannedTasksUpdate(id, data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesUnplannedTasksUpdate: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 
$data = ; // UnplannedTask | 

try {
    $result = $api_instance->apiMaintenancesUnplannedTasksUpdate($id, $data);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiMaintenancesUnplannedTasksUpdate: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 
my $data = WWW::SwaggerClient::Object::UnplannedTask->new(); # UnplannedTask | 

eval { 
    my $result = $api_instance->apiMaintenancesUnplannedTasksUpdate(id => $id, data => $data);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiApi->apiMaintenancesUnplannedTasksUpdate: $@\n";
}

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 
data =  # UnplannedTask | 

try: 
    api_response = api_instance.api_maintenances_unplanned_tasks_update(id, data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesUnplannedTasksUpdate: %s\n" % e)

Parameters

Path parameters

Name	Description
id*	String Required

Body parameters

Name	Description
data *

Responses

Status: 200 -

Schema

apiMaintenancesWorkOrdersCreate

/api/maintenances/work-orders/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/work-orders/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        MaintenanceWorkOrderCreate data = ; // MaintenanceWorkOrderCreate | 
        try {
            MaintenanceWorkOrderCreate result = apiInstance.apiMaintenancesWorkOrdersCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesWorkOrdersCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        MaintenanceWorkOrderCreate data = ; // MaintenanceWorkOrderCreate | 
        try {
            MaintenanceWorkOrderCreate result = apiInstance.apiMaintenancesWorkOrdersCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesWorkOrdersCreate");
            e.printStackTrace();
        }
    }
}

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

MaintenanceWorkOrderCreate *data = ; // 

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

[apiInstance apiMaintenancesWorkOrdersCreateWith:data
              completionHandler: ^(MaintenanceWorkOrderCreate output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var data = ; // {MaintenanceWorkOrderCreate} 


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

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

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

            var apiInstance = new ApiApi();
            var data = new MaintenanceWorkOrderCreate(); // MaintenanceWorkOrderCreate | 

            try
            {
                MaintenanceWorkOrderCreate result = apiInstance.apiMaintenancesWorkOrdersCreate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesWorkOrdersCreate: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$data = ; // MaintenanceWorkOrderCreate | 

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $data = WWW::SwaggerClient::Object::MaintenanceWorkOrderCreate->new(); # MaintenanceWorkOrderCreate | 

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
data =  # MaintenanceWorkOrderCreate | 

try: 
    api_response = api_instance.api_maintenances_work_orders_create(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesWorkOrdersCreate: %s\n" % e)

Parameters

Body parameters

Name	Description
data *

Responses

Status: 201 -

Schema

apiMaintenancesWorkOrdersDelete

/api/maintenances/work-orders/{id}/

Usage and SDK Samples

curl -X DELETE -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/work-orders/{id}/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiMaintenancesWorkOrdersDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesWorkOrdersDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiMaintenancesWorkOrdersDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesWorkOrdersDelete");
            e.printStackTrace();
        }
    }
}

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

String *id = id_example; // 

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

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

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 


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

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

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

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 

            try
            {
                apiInstance.apiMaintenancesWorkOrdersDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesWorkOrdersDelete: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->apiMaintenancesWorkOrdersDelete(id => $id);
};
if ($@) {
    warn "Exception when calling ApiApi->apiMaintenancesWorkOrdersDelete: $@\n";
}

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 

try: 
    api_instance.api_maintenances_work_orders_delete(id)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesWorkOrdersDelete: %s\n" % e)

Parameters

Path parameters

Name	Description
id*	String Required

Responses

Status: 204 -

apiMaintenancesWorkOrdersList

/api/maintenances/work-orders/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/work-orders/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        try {
            array[MaintenanceWorkOrder] result = apiInstance.apiMaintenancesWorkOrdersList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesWorkOrdersList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            array[MaintenanceWorkOrder] result = apiInstance.apiMaintenancesWorkOrdersList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesWorkOrdersList");
            e.printStackTrace();
        }
    }
}

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


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

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

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

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

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

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

            var apiInstance = new ApiApi();

            try
            {
                array[MaintenanceWorkOrder] result = apiInstance.apiMaintenancesWorkOrdersList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesWorkOrdersList: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.api_maintenances_work_orders_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesWorkOrdersList: %s\n" % e)

Parameters

Responses

Status: 200 -

Schema

apiMaintenancesWorkOrdersPartialUpdate

/api/maintenances/work-orders/{id}/

Usage and SDK Samples

curl -X PATCH -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/work-orders/{id}/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        MaintenanceWorkOrderCreate data = ; // MaintenanceWorkOrderCreate | 
        try {
            MaintenanceWorkOrderCreate result = apiInstance.apiMaintenancesWorkOrdersPartialUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesWorkOrdersPartialUpdate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        MaintenanceWorkOrderCreate data = ; // MaintenanceWorkOrderCreate | 
        try {
            MaintenanceWorkOrderCreate result = apiInstance.apiMaintenancesWorkOrdersPartialUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesWorkOrdersPartialUpdate");
            e.printStackTrace();
        }
    }
}

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

String *id = id_example; // 
MaintenanceWorkOrderCreate *data = ; // 

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

[apiInstance apiMaintenancesWorkOrdersPartialUpdateWith:id
    data:data
              completionHandler: ^(MaintenanceWorkOrderCreate output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 

var data = ; // {MaintenanceWorkOrderCreate} 


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

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

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

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 
            var data = new MaintenanceWorkOrderCreate(); // MaintenanceWorkOrderCreate | 

            try
            {
                MaintenanceWorkOrderCreate result = apiInstance.apiMaintenancesWorkOrdersPartialUpdate(id, data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesWorkOrdersPartialUpdate: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 
$data = ; // MaintenanceWorkOrderCreate | 

try {
    $result = $api_instance->apiMaintenancesWorkOrdersPartialUpdate($id, $data);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiMaintenancesWorkOrdersPartialUpdate: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 
my $data = WWW::SwaggerClient::Object::MaintenanceWorkOrderCreate->new(); # MaintenanceWorkOrderCreate | 

eval { 
    my $result = $api_instance->apiMaintenancesWorkOrdersPartialUpdate(id => $id, data => $data);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiApi->apiMaintenancesWorkOrdersPartialUpdate: $@\n";
}

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 
data =  # MaintenanceWorkOrderCreate | 

try: 
    api_response = api_instance.api_maintenances_work_orders_partial_update(id, data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesWorkOrdersPartialUpdate: %s\n" % e)

Parameters

Path parameters

Name	Description
id*	String Required

Body parameters

Name	Description
data *

Responses

Status: 200 -

Schema

apiMaintenancesWorkOrdersRead

/api/maintenances/work-orders/{id}/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/work-orders/{id}/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            MaintenanceWorkOrder result = apiInstance.apiMaintenancesWorkOrdersRead(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesWorkOrdersRead");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            MaintenanceWorkOrder result = apiInstance.apiMaintenancesWorkOrdersRead(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesWorkOrdersRead");
            e.printStackTrace();
        }
    }
}

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

String *id = id_example; // 

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

[apiInstance apiMaintenancesWorkOrdersReadWith:id
              completionHandler: ^(MaintenanceWorkOrder output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 


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

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

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

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 

            try
            {
                MaintenanceWorkOrder result = apiInstance.apiMaintenancesWorkOrdersRead(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesWorkOrdersRead: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 

try: 
    api_response = api_instance.api_maintenances_work_orders_read(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesWorkOrdersRead: %s\n" % e)

Parameters

Path parameters

Name	Description
id*	String Required

Responses

Status: 200 -

Schema

apiMaintenancesWorkOrdersUpdate

/api/maintenances/work-orders/{id}/

Usage and SDK Samples

curl -X PUT -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/work-orders/{id}/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        MaintenanceWorkOrderCreate data = ; // MaintenanceWorkOrderCreate | 
        try {
            MaintenanceWorkOrderCreate result = apiInstance.apiMaintenancesWorkOrdersUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesWorkOrdersUpdate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        MaintenanceWorkOrderCreate data = ; // MaintenanceWorkOrderCreate | 
        try {
            MaintenanceWorkOrderCreate result = apiInstance.apiMaintenancesWorkOrdersUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesWorkOrdersUpdate");
            e.printStackTrace();
        }
    }
}

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

String *id = id_example; // 
MaintenanceWorkOrderCreate *data = ; // 

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

[apiInstance apiMaintenancesWorkOrdersUpdateWith:id
    data:data
              completionHandler: ^(MaintenanceWorkOrderCreate output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 

var data = ; // {MaintenanceWorkOrderCreate} 


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

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

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

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 
            var data = new MaintenanceWorkOrderCreate(); // MaintenanceWorkOrderCreate | 

            try
            {
                MaintenanceWorkOrderCreate result = apiInstance.apiMaintenancesWorkOrdersUpdate(id, data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesWorkOrdersUpdate: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 
$data = ; // MaintenanceWorkOrderCreate | 

try {
    $result = $api_instance->apiMaintenancesWorkOrdersUpdate($id, $data);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiMaintenancesWorkOrdersUpdate: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 
my $data = WWW::SwaggerClient::Object::MaintenanceWorkOrderCreate->new(); # MaintenanceWorkOrderCreate | 

eval { 
    my $result = $api_instance->apiMaintenancesWorkOrdersUpdate(id => $id, data => $data);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiApi->apiMaintenancesWorkOrdersUpdate: $@\n";
}

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 
data =  # MaintenanceWorkOrderCreate | 

try: 
    api_response = api_instance.api_maintenances_work_orders_update(id, data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesWorkOrdersUpdate: %s\n" % e)

Parameters

Path parameters

Name	Description
id*	String Required

Body parameters

Name	Description
data *

Responses

Status: 200 -

Schema

apiMixingsIngredientCreate

/api/mixings/ingredient/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/mixings/ingredient/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        MixIngredient data = ; // MixIngredient | 
        try {
            MixIngredient result = apiInstance.apiMixingsIngredientCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMixingsIngredientCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        MixIngredient data = ; // MixIngredient | 
        try {
            MixIngredient result = apiInstance.apiMixingsIngredientCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMixingsIngredientCreate");
            e.printStackTrace();
        }
    }
}

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

MixIngredient *data = ; // 

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

[apiInstance apiMixingsIngredientCreateWith:data
              completionHandler: ^(MixIngredient output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var data = ; // {MixIngredient} 


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

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

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

            var apiInstance = new ApiApi();
            var data = new MixIngredient(); // MixIngredient | 

            try
            {
                MixIngredient result = apiInstance.apiMixingsIngredientCreate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMixingsIngredientCreate: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$data = ; // MixIngredient | 

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $data = WWW::SwaggerClient::Object::MixIngredient->new(); # MixIngredient | 

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
data =  # MixIngredient | 

try: 
    api_response = api_instance.api_mixings_ingredient_create(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMixingsIngredientCreate: %s\n" % e)

Parameters

Body parameters

Name	Description
data *

Responses

Status: 201 -

Schema

apiMixingsIngredientList

/api/mixings/ingredient/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/mixings/ingredient/?page="

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        Integer page = 56; // Integer | A page number within the paginated result set.
        try {
            inline_response_200_2 result = apiInstance.apiMixingsIngredientList(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMixingsIngredientList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Integer page = 56; // Integer | A page number within the paginated result set.
        try {
            inline_response_200_2 result = apiInstance.apiMixingsIngredientList(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMixingsIngredientList");
            e.printStackTrace();
        }
    }
}

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

Integer *page = 56; // A page number within the paginated result set. (optional)

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

[apiInstance apiMixingsIngredientListWith:page
              completionHandler: ^(inline_response_200_2 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var opts = { 
  'page': 56 // {Integer} A page number within the paginated result set.
};

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

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

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

            var apiInstance = new ApiApi();
            var page = 56;  // Integer | A page number within the paginated result set. (optional) 

            try
            {
                inline_response_200_2 result = apiInstance.apiMixingsIngredientList(page);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMixingsIngredientList: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$page = 56; // Integer | A page number within the paginated result set.

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $page = 56; # Integer | A page number within the paginated result set.

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
page = 56 # Integer | A page number within the paginated result set. (optional)

try: 
    api_response = api_instance.api_mixings_ingredient_list(page=page)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMixingsIngredientList: %s\n" % e)

Parameters

Query parameters

Name	Description
page	Integer A page number within the paginated result set.

Responses

Status: 200 -

Schema

apiMixingsProducedCreate

/api/mixings/produced/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/mixings/produced/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        MixProduced data = ; // MixProduced | 
        try {
            MixProduced result = apiInstance.apiMixingsProducedCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMixingsProducedCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        MixProduced data = ; // MixProduced | 
        try {
            MixProduced result = apiInstance.apiMixingsProducedCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMixingsProducedCreate");
            e.printStackTrace();
        }
    }
}

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

MixProduced *data = ; // 

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

[apiInstance apiMixingsProducedCreateWith:data
              completionHandler: ^(MixProduced output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var data = ; // {MixProduced} 


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

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

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

            var apiInstance = new ApiApi();
            var data = new MixProduced(); // MixProduced | 

            try
            {
                MixProduced result = apiInstance.apiMixingsProducedCreate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMixingsProducedCreate: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$data = ; // MixProduced | 

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $data = WWW::SwaggerClient::Object::MixProduced->new(); # MixProduced | 

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
data =  # MixProduced | 

try: 
    api_response = api_instance.api_mixings_produced_create(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMixingsProducedCreate: %s\n" % e)

Parameters

Body parameters

Name	Description
data *

Responses

Status: 201 -

Schema

apiMixingsProducedList

/api/mixings/produced/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/mixings/produced/?page="

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        Integer page = 56; // Integer | A page number within the paginated result set.
        try {
            inline_response_200_3 result = apiInstance.apiMixingsProducedList(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMixingsProducedList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Integer page = 56; // Integer | A page number within the paginated result set.
        try {
            inline_response_200_3 result = apiInstance.apiMixingsProducedList(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMixingsProducedList");
            e.printStackTrace();
        }
    }
}

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

Integer *page = 56; // A page number within the paginated result set. (optional)

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

[apiInstance apiMixingsProducedListWith:page
              completionHandler: ^(inline_response_200_3 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var opts = { 
  'page': 56 // {Integer} A page number within the paginated result set.
};

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

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

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

            var apiInstance = new ApiApi();
            var page = 56;  // Integer | A page number within the paginated result set. (optional) 

            try
            {
                inline_response_200_3 result = apiInstance.apiMixingsProducedList(page);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMixingsProducedList: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$page = 56; // Integer | A page number within the paginated result set.

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $page = 56; # Integer | A page number within the paginated result set.

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
page = 56 # Integer | A page number within the paginated result set. (optional)

try: 
    api_response = api_instance.api_mixings_produced_list(page=page)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMixingsProducedList: %s\n" % e)

Parameters

Query parameters

Name	Description
page	Integer A page number within the paginated result set.

Responses

Status: 200 -

Schema

apiMixingsScaleOnlyList

/api/mixings/scale-only/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/mixings/scale-only/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiMixingsScaleOnlyList();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMixingsScaleOnlyList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

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

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


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

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

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

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

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

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

            var apiInstance = new ApiApi();

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

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.api_mixings_scale_only_list()
except ApiException as e:
    print("Exception when calling ApiApi->apiMixingsScaleOnlyList: %s\n" % e)

Parameters

Responses

Status: 200 -

apiPlanningProductionPlansCreate

/api/planning/production-plans/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/planning/production-plans/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        ProductionPlan data = ; // ProductionPlan | 
        try {
            ProductionPlan result = apiInstance.apiPlanningProductionPlansCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiPlanningProductionPlansCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        ProductionPlan data = ; // ProductionPlan | 
        try {
            ProductionPlan result = apiInstance.apiPlanningProductionPlansCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiPlanningProductionPlansCreate");
            e.printStackTrace();
        }
    }
}

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

ProductionPlan *data = ; // 

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

[apiInstance apiPlanningProductionPlansCreateWith:data
              completionHandler: ^(ProductionPlan output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var data = ; // {ProductionPlan} 


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

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

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

            var apiInstance = new ApiApi();
            var data = new ProductionPlan(); // ProductionPlan | 

            try
            {
                ProductionPlan result = apiInstance.apiPlanningProductionPlansCreate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiPlanningProductionPlansCreate: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$data = ; // ProductionPlan | 

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $data = WWW::SwaggerClient::Object::ProductionPlan->new(); # ProductionPlan | 

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
data =  # ProductionPlan | 

try: 
    api_response = api_instance.api_planning_production_plans_create(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiPlanningProductionPlansCreate: %s\n" % e)

Parameters

Body parameters

Name	Description
data *

Responses

Status: 201 -

Schema

apiPlanningProductionPlansDelete

/api/planning/production-plans/{id}/

Usage and SDK Samples

curl -X DELETE -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/planning/production-plans/{id}/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        Integer id = 56; // Integer | A unique integer value identifying this Plan.
        try {
            apiInstance.apiPlanningProductionPlansDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiPlanningProductionPlansDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Integer id = 56; // Integer | A unique integer value identifying this Plan.
        try {
            apiInstance.apiPlanningProductionPlansDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiPlanningProductionPlansDelete");
            e.printStackTrace();
        }
    }
}

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

Integer *id = 56; // A unique integer value identifying this Plan.

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

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

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var id = 56; // {Integer} A unique integer value identifying this Plan.


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

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

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

            var apiInstance = new ApiApi();
            var id = 56;  // Integer | A unique integer value identifying this Plan.

            try
            {
                apiInstance.apiPlanningProductionPlansDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiPlanningProductionPlansDelete: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = 56; // Integer | A unique integer value identifying this Plan.

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = 56; # Integer | A unique integer value identifying this Plan.

eval { 
    $api_instance->apiPlanningProductionPlansDelete(id => $id);
};
if ($@) {
    warn "Exception when calling ApiApi->apiPlanningProductionPlansDelete: $@\n";
}

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = 56 # Integer | A unique integer value identifying this Plan.

try: 
    api_instance.api_planning_production_plans_delete(id)
except ApiException as e:
    print("Exception when calling ApiApi->apiPlanningProductionPlansDelete: %s\n" % e)

Parameters

Path parameters

Name	Description
id*	Integer A unique integer value identifying this Plan. Required

Responses

Status: 204 -

apiPlanningProductionPlansList

/api/planning/production-plans/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/planning/production-plans/?page="

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        Integer page = 56; // Integer | A page number within the paginated result set.
        try {
            inline_response_200_4 result = apiInstance.apiPlanningProductionPlansList(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiPlanningProductionPlansList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Integer page = 56; // Integer | A page number within the paginated result set.
        try {
            inline_response_200_4 result = apiInstance.apiPlanningProductionPlansList(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiPlanningProductionPlansList");
            e.printStackTrace();
        }
    }
}

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

Integer *page = 56; // A page number within the paginated result set. (optional)

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

[apiInstance apiPlanningProductionPlansListWith:page
              completionHandler: ^(inline_response_200_4 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var opts = { 
  'page': 56 // {Integer} A page number within the paginated result set.
};

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

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

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

            var apiInstance = new ApiApi();
            var page = 56;  // Integer | A page number within the paginated result set. (optional) 

            try
            {
                inline_response_200_4 result = apiInstance.apiPlanningProductionPlansList(page);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiPlanningProductionPlansList: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$page = 56; // Integer | A page number within the paginated result set.

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $page = 56; # Integer | A page number within the paginated result set.

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
page = 56 # Integer | A page number within the paginated result set. (optional)

try: 
    api_response = api_instance.api_planning_production_plans_list(page=page)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiPlanningProductionPlansList: %s\n" % e)

Parameters

Query parameters

Name	Description
page	Integer A page number within the paginated result set.

Responses

Status: 200 -

Schema

apiPlanningProductionPlansPartialUpdate

/api/planning/production-plans/{id}/

Usage and SDK Samples

curl -X PATCH -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/planning/production-plans/{id}/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        Integer id = 56; // Integer | A unique integer value identifying this Plan.
        ProductionPlan data = ; // ProductionPlan | 
        try {
            ProductionPlan result = apiInstance.apiPlanningProductionPlansPartialUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiPlanningProductionPlansPartialUpdate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Integer id = 56; // Integer | A unique integer value identifying this Plan.
        ProductionPlan data = ; // ProductionPlan | 
        try {
            ProductionPlan result = apiInstance.apiPlanningProductionPlansPartialUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiPlanningProductionPlansPartialUpdate");
            e.printStackTrace();
        }
    }
}

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

Integer *id = 56; // A unique integer value identifying this Plan.
ProductionPlan *data = ; // 

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

[apiInstance apiPlanningProductionPlansPartialUpdateWith:id
    data:data
              completionHandler: ^(ProductionPlan output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var id = 56; // {Integer} A unique integer value identifying this Plan.

var data = ; // {ProductionPlan} 


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

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

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

            var apiInstance = new ApiApi();
            var id = 56;  // Integer | A unique integer value identifying this Plan.
            var data = new ProductionPlan(); // ProductionPlan | 

            try
            {
                ProductionPlan result = apiInstance.apiPlanningProductionPlansPartialUpdate(id, data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiPlanningProductionPlansPartialUpdate: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = 56; // Integer | A unique integer value identifying this Plan.
$data = ; // ProductionPlan | 

try {
    $result = $api_instance->apiPlanningProductionPlansPartialUpdate($id, $data);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiPlanningProductionPlansPartialUpdate: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = 56; # Integer | A unique integer value identifying this Plan.
my $data = WWW::SwaggerClient::Object::ProductionPlan->new(); # ProductionPlan | 

eval { 
    my $result = $api_instance->apiPlanningProductionPlansPartialUpdate(id => $id, data => $data);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiApi->apiPlanningProductionPlansPartialUpdate: $@\n";
}

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = 56 # Integer | A unique integer value identifying this Plan.
data =  # ProductionPlan | 

try: 
    api_response = api_instance.api_planning_production_plans_partial_update(id, data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiPlanningProductionPlansPartialUpdate: %s\n" % e)

Parameters

Path parameters

Name	Description
id*	Integer A unique integer value identifying this Plan. Required

Body parameters

Name	Description
data *

Responses

Status: 200 -

Schema

apiPlanningProductionPlansRead

/api/planning/production-plans/{id}/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/planning/production-plans/{id}/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        Integer id = 56; // Integer | A unique integer value identifying this Plan.
        try {
            ProductionPlan result = apiInstance.apiPlanningProductionPlansRead(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiPlanningProductionPlansRead");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Integer id = 56; // Integer | A unique integer value identifying this Plan.
        try {
            ProductionPlan result = apiInstance.apiPlanningProductionPlansRead(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiPlanningProductionPlansRead");
            e.printStackTrace();
        }
    }
}

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

Integer *id = 56; // A unique integer value identifying this Plan.

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

[apiInstance apiPlanningProductionPlansReadWith:id
              completionHandler: ^(ProductionPlan output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var id = 56; // {Integer} A unique integer value identifying this Plan.


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

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

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

            var apiInstance = new ApiApi();
            var id = 56;  // Integer | A unique integer value identifying this Plan.

            try
            {
                ProductionPlan result = apiInstance.apiPlanningProductionPlansRead(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiPlanningProductionPlansRead: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = 56; // Integer | A unique integer value identifying this Plan.

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = 56; # Integer | A unique integer value identifying this Plan.

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = 56 # Integer | A unique integer value identifying this Plan.

try: 
    api_response = api_instance.api_planning_production_plans_read(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiPlanningProductionPlansRead: %s\n" % e)

Parameters

Path parameters

Name	Description
id*	Integer A unique integer value identifying this Plan. Required

Responses

Status: 200 -

Schema

apiPlanningProductionPlansUpdate

/api/planning/production-plans/{id}/

Usage and SDK Samples

curl -X PUT -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/planning/production-plans/{id}/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        Integer id = 56; // Integer | A unique integer value identifying this Plan.
        ProductionPlan data = ; // ProductionPlan | 
        try {
            ProductionPlan result = apiInstance.apiPlanningProductionPlansUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiPlanningProductionPlansUpdate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Integer id = 56; // Integer | A unique integer value identifying this Plan.
        ProductionPlan data = ; // ProductionPlan | 
        try {
            ProductionPlan result = apiInstance.apiPlanningProductionPlansUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiPlanningProductionPlansUpdate");
            e.printStackTrace();
        }
    }
}

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

Integer *id = 56; // A unique integer value identifying this Plan.
ProductionPlan *data = ; // 

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

[apiInstance apiPlanningProductionPlansUpdateWith:id
    data:data
              completionHandler: ^(ProductionPlan output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var id = 56; // {Integer} A unique integer value identifying this Plan.

var data = ; // {ProductionPlan} 


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

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

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

            var apiInstance = new ApiApi();
            var id = 56;  // Integer | A unique integer value identifying this Plan.
            var data = new ProductionPlan(); // ProductionPlan | 

            try
            {
                ProductionPlan result = apiInstance.apiPlanningProductionPlansUpdate(id, data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiPlanningProductionPlansUpdate: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = 56; // Integer | A unique integer value identifying this Plan.
$data = ; // ProductionPlan | 

try {
    $result = $api_instance->apiPlanningProductionPlansUpdate($id, $data);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiPlanningProductionPlansUpdate: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = 56; # Integer | A unique integer value identifying this Plan.
my $data = WWW::SwaggerClient::Object::ProductionPlan->new(); # ProductionPlan | 

eval { 
    my $result = $api_instance->apiPlanningProductionPlansUpdate(id => $id, data => $data);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiApi->apiPlanningProductionPlansUpdate: $@\n";
}

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = 56 # Integer | A unique integer value identifying this Plan.
data =  # ProductionPlan | 

try: 
    api_response = api_instance.api_planning_production_plans_update(id, data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiPlanningProductionPlansUpdate: %s\n" % e)

Parameters

Path parameters

Name	Description
id*	Integer A unique integer value identifying this Plan. Required

Body parameters

Name	Description
data *

Responses

Status: 200 -

Schema

apiPlantMachineriesList

/api/plant/machineries/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/plant/machineries/"

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

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

public class ApiApiExample {

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

        ApiApi apiInstance = new ApiApi();
        try {
            array[PlantPlantMachinery] result = apiInstance.apiPlantMachineriesList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiPlantMachineriesList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            array[PlantPlantMachinery] result = apiInstance.apiPlantMachineriesList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiPlantMachineriesList");
            e.printStackTrace();
        }
    }
}

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


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

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

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

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

var api = new InternalTraceSenseApi.ApiApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiPlantMachineriesList(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiPlantMachineriesListExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                array[PlantPlantMachinery] result = apiInstance.apiPlantMachineriesList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiPlantMachineriesList: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

try {
    $result = $api_instance->apiPlantMachineriesList();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiPlantMachineriesList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();

eval { 
    my $result = $api_instance->apiPlantMachineriesList();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiApi->apiPlantMachineriesList: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()

try: 
    api_response = api_instance.api_plant_machineries_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiPlantMachineriesList: %s\n" % e)

Parameters

Responses

Status: 200 -

Schema

apiPlantMachineriesRead

/api/plant/machineries/{id}/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/plant/machineries/{id}/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

import java.io.File;
import java.util.*;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            PlantPlantMachinery result = apiInstance.apiPlantMachineriesRead(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiPlantMachineriesRead");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            PlantPlantMachinery result = apiInstance.apiPlantMachineriesRead(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiPlantMachineriesRead");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

ApiApi *apiInstance = [[ApiApi alloc] init];

[apiInstance apiPlantMachineriesReadWith:id
              completionHandler: ^(PlantPlantMachinery output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiPlantMachineriesRead(id, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiPlantMachineriesReadExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 

            try
            {
                PlantPlantMachinery result = apiInstance.apiPlantMachineriesRead(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiPlantMachineriesRead: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 

try {
    $result = $api_instance->apiPlantMachineriesRead($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiPlantMachineriesRead: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 

eval { 
    my $result = $api_instance->apiPlantMachineriesRead(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiApi->apiPlantMachineriesRead: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 

try: 
    api_response = api_instance.api_plant_machineries_read(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiPlantMachineriesRead: %s\n" % e)

Parameters

Path parameters

Name	Description
id*	String Required

Responses

Status: 200 -

Schema

apiProcessGetRecipesList

/api/process/get/recipes/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/process/get/recipes/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

import java.io.File;
import java.util.*;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            array[Recipes] result = apiInstance.apiProcessGetRecipesList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiProcessGetRecipesList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            array[Recipes] result = apiInstance.apiProcessGetRecipesList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiProcessGetRecipesList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


ApiApi *apiInstance = [[ApiApi alloc] init];

[apiInstance apiProcessGetRecipesListWithCompletionHandler: 
              ^(array[Recipes] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiProcessGetRecipesList(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiProcessGetRecipesListExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                array[Recipes] result = apiInstance.apiProcessGetRecipesList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiProcessGetRecipesList: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

try {
    $result = $api_instance->apiProcessGetRecipesList();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiProcessGetRecipesList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();

eval { 
    my $result = $api_instance->apiProcessGetRecipesList();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiApi->apiProcessGetRecipesList: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()

try: 
    api_response = api_instance.api_process_get_recipes_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiProcessGetRecipesList: %s\n" % e)

Parameters

Responses

Status: 200 -

Schema

apiProcessGetRequirementsList

/api/process/get/requirements/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/process/get/requirements/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

import java.io.File;
import java.util.*;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            array[Requirements] result = apiInstance.apiProcessGetRequirementsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiProcessGetRequirementsList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            array[Requirements] result = apiInstance.apiProcessGetRequirementsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiProcessGetRequirementsList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


ApiApi *apiInstance = [[ApiApi alloc] init];

[apiInstance apiProcessGetRequirementsListWithCompletionHandler: 
              ^(array[Requirements] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiProcessGetRequirementsList(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiProcessGetRequirementsListExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                array[Requirements] result = apiInstance.apiProcessGetRequirementsList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiProcessGetRequirementsList: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

try {
    $result = $api_instance->apiProcessGetRequirementsList();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiProcessGetRequirementsList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();

eval { 
    my $result = $api_instance->apiProcessGetRequirementsList();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiApi->apiProcessGetRequirementsList: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()

try: 
    api_response = api_instance.api_process_get_requirements_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiProcessGetRequirementsList: %s\n" % e)

Parameters

Responses

Status: 200 -

Schema

apiProcessRecipeAddCreate

Checks relevant directory and inserts data into database

/api/process/recipe/add

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/process/recipe/add"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

import java.io.File;
import java.util.*;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiProcessRecipeAddCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiProcessRecipeAddCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiProcessRecipeAddCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiProcessRecipeAddCreate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


ApiApi *apiInstance = [[ApiApi alloc] init];

[apiInstance apiProcessRecipeAddCreateWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiProcessRecipeAddCreate(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiProcessRecipeAddCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                apiInstance.apiProcessRecipeAddCreate();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiProcessRecipeAddCreate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

try {
    $api_instance->apiProcessRecipeAddCreate();
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiProcessRecipeAddCreate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();

eval { 
    $api_instance->apiProcessRecipeAddCreate();
};
if ($@) {
    warn "Exception when calling ApiApi->apiProcessRecipeAddCreate: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()

try: 
    api_instance.api_process_recipe_add_create()
except ApiException as e:
    print("Exception when calling ApiApi->apiProcessRecipeAddCreate: %s\n" % e)

Parameters

Responses

Status: 201 -

apiProcessRecipeRequirementsList

/api/process/recipe/requirements/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/process/recipe/requirements/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

import java.io.File;
import java.util.*;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            array[Requirements] result = apiInstance.apiProcessRecipeRequirementsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiProcessRecipeRequirementsList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            array[Requirements] result = apiInstance.apiProcessRecipeRequirementsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiProcessRecipeRequirementsList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


ApiApi *apiInstance = [[ApiApi alloc] init];

[apiInstance apiProcessRecipeRequirementsListWithCompletionHandler: 
              ^(array[Requirements] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiProcessRecipeRequirementsList(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiProcessRecipeRequirementsListExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                array[Requirements] result = apiInstance.apiProcessRecipeRequirementsList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiProcessRecipeRequirementsList: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

try {
    $result = $api_instance->apiProcessRecipeRequirementsList();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiProcessRecipeRequirementsList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();

eval { 
    my $result = $api_instance->apiProcessRecipeRequirementsList();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiApi->apiProcessRecipeRequirementsList: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()

try: 
    api_response = api_instance.api_process_recipe_requirements_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiProcessRecipeRequirementsList: %s\n" % e)

Parameters

Responses

Status: 200 -

Schema

apiProcessRecipeStepsCreate

/api/process/recipe/steps/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/process/recipe/steps/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

import java.io.File;
import java.util.*;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiProcessRecipeStepsCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiProcessRecipeStepsCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiProcessRecipeStepsCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiProcessRecipeStepsCreate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


ApiApi *apiInstance = [[ApiApi alloc] init];

[apiInstance apiProcessRecipeStepsCreateWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiProcessRecipeStepsCreate(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiProcessRecipeStepsCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                apiInstance.apiProcessRecipeStepsCreate();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiProcessRecipeStepsCreate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

try {
    $api_instance->apiProcessRecipeStepsCreate();
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiProcessRecipeStepsCreate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();

eval { 
    $api_instance->apiProcessRecipeStepsCreate();
};
if ($@) {
    warn "Exception when calling ApiApi->apiProcessRecipeStepsCreate: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()

try: 
    api_instance.api_process_recipe_steps_create()
except ApiException as e:
    print("Exception when calling ApiApi->apiProcessRecipeStepsCreate: %s\n" % e)

Parameters

Responses

Status: 201 -

apiProcessRequirementsCreate

/api/process/requirements/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/process/requirements/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

import java.io.File;
import java.util.*;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        Requirements data = ; // Requirements | 
        try {
            Requirements result = apiInstance.apiProcessRequirementsCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiProcessRequirementsCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Requirements data = ; // Requirements | 
        try {
            Requirements result = apiInstance.apiProcessRequirementsCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiProcessRequirementsCreate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Requirements *data = ; // 

ApiApi *apiInstance = [[ApiApi alloc] init];

[apiInstance apiProcessRequirementsCreateWith:data
              completionHandler: ^(Requirements output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var data = ; // {Requirements} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiProcessRequirementsCreate(data, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiProcessRequirementsCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var data = new Requirements(); // Requirements | 

            try
            {
                Requirements result = apiInstance.apiProcessRequirementsCreate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiProcessRequirementsCreate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$data = ; // Requirements | 

try {
    $result = $api_instance->apiProcessRequirementsCreate($data);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiProcessRequirementsCreate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $data = WWW::SwaggerClient::Object::Requirements->new(); # Requirements | 

eval { 
    my $result = $api_instance->apiProcessRequirementsCreate(data => $data);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiApi->apiProcessRequirementsCreate: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
data =  # Requirements | 

try: 
    api_response = api_instance.api_process_requirements_create(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiProcessRequirementsCreate: %s\n" % e)

Parameters

Body parameters

Name	Description
data *

Responses

Status: 201 -

Schema

apiProcessRequirementsDelete

/api/process/requirements/{id}/

Usage and SDK Samples

curl -X DELETE -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/process/requirements/{id}/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

import java.io.File;
import java.util.*;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        Integer id = 56; // Integer | A unique integer value identifying this Requirement.
        try {
            apiInstance.apiProcessRequirementsDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiProcessRequirementsDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Integer id = 56; // Integer | A unique integer value identifying this Requirement.
        try {
            apiInstance.apiProcessRequirementsDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiProcessRequirementsDelete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *id = 56; // A unique integer value identifying this Requirement.

ApiApi *apiInstance = [[ApiApi alloc] init];

[apiInstance apiProcessRequirementsDeleteWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var id = 56; // {Integer} A unique integer value identifying this Requirement.


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiProcessRequirementsDelete(id, , callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiProcessRequirementsDeleteExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var id = 56;  // Integer | A unique integer value identifying this Requirement.

            try
            {
                apiInstance.apiProcessRequirementsDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiProcessRequirementsDelete: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = 56; // Integer | A unique integer value identifying this Requirement.

try {
    $api_instance->apiProcessRequirementsDelete($id);
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiProcessRequirementsDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = 56; # Integer | A unique integer value identifying this Requirement.

eval { 
    $api_instance->apiProcessRequirementsDelete(id => $id);
};
if ($@) {
    warn "Exception when calling ApiApi->apiProcessRequirementsDelete: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = 56 # Integer | A unique integer value identifying this Requirement.

try: 
    api_instance.api_process_requirements_delete(id)
except ApiException as e:
    print("Exception when calling ApiApi->apiProcessRequirementsDelete: %s\n" % e)

Parameters

Path parameters

Name	Description
id*	Integer A unique integer value identifying this Requirement. Required

Responses

Status: 204 -

apiProcessRequirementsGenerateBatchNumber

/api/process/requirements/generate_batch_number/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/process/requirements/generate_batch_number/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

import java.io.File;
import java.util.*;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        Requirements data = ; // Requirements | 
        try {
            Requirements result = apiInstance.apiProcessRequirementsGenerateBatchNumber(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiProcessRequirementsGenerateBatchNumber");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Requirements data = ; // Requirements | 
        try {
            Requirements result = apiInstance.apiProcessRequirementsGenerateBatchNumber(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiProcessRequirementsGenerateBatchNumber");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Requirements *data = ; // 

ApiApi *apiInstance = [[ApiApi alloc] init];

[apiInstance apiProcessRequirementsGenerateBatchNumberWith:data
              completionHandler: ^(Requirements output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var data = ; // {Requirements} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiProcessRequirementsGenerateBatchNumber(data, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiProcessRequirementsGenerateBatchNumberExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var data = new Requirements(); // Requirements | 

            try
            {
                Requirements result = apiInstance.apiProcessRequirementsGenerateBatchNumber(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiProcessRequirementsGenerateBatchNumber: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$data = ; // Requirements | 

try {
    $result = $api_instance->apiProcessRequirementsGenerateBatchNumber($data);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiProcessRequirementsGenerateBatchNumber: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $data = WWW::SwaggerClient::Object::Requirements->new(); # Requirements | 

eval { 
    my $result = $api_instance->apiProcessRequirementsGenerateBatchNumber(data => $data);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiApi->apiProcessRequirementsGenerateBatchNumber: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
data =  # Requirements | 

try: 
    api_response = api_instance.api_process_requirements_generate_batch_number(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiProcessRequirementsGenerateBatchNumber: %s\n" % e)

Parameters

Body parameters

Name	Description
data *

Responses

Status: 201 -

Schema

apiProcessRequirementsList

/api/process/requirements/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/process/requirements/?page="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

import java.io.File;
import java.util.*;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        Integer page = 56; // Integer | A page number within the paginated result set.
        try {
            inline_response_200_5 result = apiInstance.apiProcessRequirementsList(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiProcessRequirementsList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Integer page = 56; // Integer | A page number within the paginated result set.
        try {
            inline_response_200_5 result = apiInstance.apiProcessRequirementsList(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiProcessRequirementsList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *page = 56; // A page number within the paginated result set. (optional)

ApiApi *apiInstance = [[ApiApi alloc] init];

[apiInstance apiProcessRequirementsListWith:page
              completionHandler: ^(inline_response_200_5 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var opts = { 
  'page': 56 // {Integer} A page number within the paginated result set.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiProcessRequirementsList(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiProcessRequirementsListExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var page = 56;  // Integer | A page number within the paginated result set. (optional) 

            try
            {
                inline_response_200_5 result = apiInstance.apiProcessRequirementsList(page);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiProcessRequirementsList: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$page = 56; // Integer | A page number within the paginated result set.

try {
    $result = $api_instance->apiProcessRequirementsList($page);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiProcessRequirementsList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $page = 56; # Integer | A page number within the paginated result set.

eval { 
    my $result = $api_instance->apiProcessRequirementsList(page => $page);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiApi->apiProcessRequirementsList: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
page = 56 # Integer | A page number within the paginated result set. (optional)

try: 
    api_response = api_instance.api_process_requirements_list(page=page)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiProcessRequirementsList: %s\n" % e)

Parameters

Query parameters

Name	Description
page	Integer A page number within the paginated result set.

Responses

Status: 200 -

Schema

apiProcessRequirementsPartialUpdate

/api/process/requirements/{id}/

Usage and SDK Samples

curl -X PATCH -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/process/requirements/{id}/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

import java.io.File;
import java.util.*;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        Integer id = 56; // Integer | A unique integer value identifying this Requirement.
        Requirements data = ; // Requirements | 
        try {
            Requirements result = apiInstance.apiProcessRequirementsPartialUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiProcessRequirementsPartialUpdate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Integer id = 56; // Integer | A unique integer value identifying this Requirement.
        Requirements data = ; // Requirements | 
        try {
            Requirements result = apiInstance.apiProcessRequirementsPartialUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiProcessRequirementsPartialUpdate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *id = 56; // A unique integer value identifying this Requirement.
Requirements *data = ; // 

ApiApi *apiInstance = [[ApiApi alloc] init];

[apiInstance apiProcessRequirementsPartialUpdateWith:id
    data:data
              completionHandler: ^(Requirements output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var id = 56; // {Integer} A unique integer value identifying this Requirement.

var data = ; // {Requirements} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiProcessRequirementsPartialUpdate(id, data, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiProcessRequirementsPartialUpdateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var id = 56;  // Integer | A unique integer value identifying this Requirement.
            var data = new Requirements(); // Requirements | 

            try
            {
                Requirements result = apiInstance.apiProcessRequirementsPartialUpdate(id, data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiProcessRequirementsPartialUpdate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = 56; // Integer | A unique integer value identifying this Requirement.
$data = ; // Requirements | 

try {
    $result = $api_instance->apiProcessRequirementsPartialUpdate($id, $data);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiProcessRequirementsPartialUpdate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = 56; # Integer | A unique integer value identifying this Requirement.
my $data = WWW::SwaggerClient::Object::Requirements->new(); # Requirements | 

eval { 
    my $result = $api_instance->apiProcessRequirementsPartialUpdate(id => $id, data => $data);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiApi->apiProcessRequirementsPartialUpdate: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = 56 # Integer | A unique integer value identifying this Requirement.
data =  # Requirements | 

try: 
    api_response = api_instance.api_process_requirements_partial_update(id, data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiProcessRequirementsPartialUpdate: %s\n" % e)

Parameters

Path parameters

Name	Description
id*	Integer A unique integer value identifying this Requirement. Required

Body parameters

Name	Description
data *

Responses

Status: 200 -

Schema

apiProcessRequirementsRead

/api/process/requirements/{id}/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/process/requirements/{id}/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

import java.io.File;
import java.util.*;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        Integer id = 56; // Integer | A unique integer value identifying this Requirement.
        try {
            Requirements result = apiInstance.apiProcessRequirementsRead(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiProcessRequirementsRead");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Integer id = 56; // Integer | A unique integer value identifying this Requirement.
        try {
            Requirements result = apiInstance.apiProcessRequirementsRead(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiProcessRequirementsRead");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *id = 56; // A unique integer value identifying this Requirement.

ApiApi *apiInstance = [[ApiApi alloc] init];

[apiInstance apiProcessRequirementsReadWith:id
              completionHandler: ^(Requirements output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var id = 56; // {Integer} A unique integer value identifying this Requirement.


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiProcessRequirementsRead(id, , callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiProcessRequirementsReadExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var id = 56;  // Integer | A unique integer value identifying this Requirement.

            try
            {
                Requirements result = apiInstance.apiProcessRequirementsRead(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiProcessRequirementsRead: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = 56; // Integer | A unique integer value identifying this Requirement.

try {
    $result = $api_instance->apiProcessRequirementsRead($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiProcessRequirementsRead: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = 56; # Integer | A unique integer value identifying this Requirement.

eval { 
    my $result = $api_instance->apiProcessRequirementsRead(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiApi->apiProcessRequirementsRead: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = 56 # Integer | A unique integer value identifying this Requirement.

try: 
    api_response = api_instance.api_process_requirements_read(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiProcessRequirementsRead: %s\n" % e)

Parameters

Path parameters

Name	Description
id*	Integer A unique integer value identifying this Requirement. Required

Responses

Status: 200 -

Schema

apiProcessRequirementsUpdate

/api/process/requirements/{id}/

Usage and SDK Samples

curl -X PUT -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/process/requirements/{id}/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

import java.io.File;
import java.util.*;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        Integer id = 56; // Integer | A unique integer value identifying this Requirement.
        Requirements data = ; // Requirements | 
        try {
            Requirements result = apiInstance.apiProcessRequirementsUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiProcessRequirementsUpdate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Integer id = 56; // Integer | A unique integer value identifying this Requirement.
        Requirements data = ; // Requirements | 
        try {
            Requirements result = apiInstance.apiProcessRequirementsUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiProcessRequirementsUpdate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *id = 56; // A unique integer value identifying this Requirement.
Requirements *data = ; // 

ApiApi *apiInstance = [[ApiApi alloc] init];

[apiInstance apiProcessRequirementsUpdateWith:id
    data:data
              completionHandler: ^(Requirements output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var id = 56; // {Integer} A unique integer value identifying this Requirement.

var data = ; // {Requirements} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiProcessRequirementsUpdate(id, data, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiProcessRequirementsUpdateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var id = 56;  // Integer | A unique integer value identifying this Requirement.
            var data = new Requirements(); // Requirements | 

            try
            {
                Requirements result = apiInstance.apiProcessRequirementsUpdate(id, data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiProcessRequirementsUpdate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = 56; // Integer | A unique integer value identifying this Requirement.
$data = ; // Requirements | 

try {
    $result = $api_instance->apiProcessRequirementsUpdate($id, $data);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiProcessRequirementsUpdate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = 56; # Integer | A unique integer value identifying this Requirement.
my $data = WWW::SwaggerClient::Object::Requirements->new(); # Requirements | 

eval { 
    my $result = $api_instance->apiProcessRequirementsUpdate(id => $id, data => $data);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiApi->apiProcessRequirementsUpdate: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = 56 # Integer | A unique integer value identifying this Requirement.
data =  # Requirements | 

try: 
    api_response = api_instance.api_process_requirements_update(id, data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiProcessRequirementsUpdate: %s\n" % e)

Parameters

Path parameters

Name	Description
id*	Integer A unique integer value identifying this Requirement. Required

Body parameters

Name	Description
data *

Responses

Status: 200 -

Schema

apiPurchaseorderV1PurchaseordersCreate

Checks relevant directories and inserts XML data into the system.

/api/purchaseorder/v1/purchaseorders/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/purchaseorder/v1/purchaseorders/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

import java.io.File;
import java.util.*;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiPurchaseorderV1PurchaseordersCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiPurchaseorderV1PurchaseordersCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiPurchaseorderV1PurchaseordersCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiPurchaseorderV1PurchaseordersCreate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


ApiApi *apiInstance = [[ApiApi alloc] init];

[apiInstance apiPurchaseorderV1PurchaseordersCreateWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiPurchaseorderV1PurchaseordersCreate(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiPurchaseorderV1PurchaseordersCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                apiInstance.apiPurchaseorderV1PurchaseordersCreate();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiPurchaseorderV1PurchaseordersCreate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

try {
    $api_instance->apiPurchaseorderV1PurchaseordersCreate();
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiPurchaseorderV1PurchaseordersCreate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();

eval { 
    $api_instance->apiPurchaseorderV1PurchaseordersCreate();
};
if ($@) {
    warn "Exception when calling ApiApi->apiPurchaseorderV1PurchaseordersCreate: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()

try: 
    api_instance.api_purchaseorder_v1_purchaseorders_create()
except ApiException as e:
    print("Exception when calling ApiApi->apiPurchaseorderV1PurchaseordersCreate: %s\n" % e)

Parameters

Responses

Status: 201 -

apiQualityAuditCreate

/api/quality/audit/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/quality/audit/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

import java.io.File;
import java.util.*;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiQualityAuditCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiQualityAuditCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiQualityAuditCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiQualityAuditCreate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


ApiApi *apiInstance = [[ApiApi alloc] init];

[apiInstance apiQualityAuditCreateWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiQualityAuditCreate(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiQualityAuditCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                apiInstance.apiQualityAuditCreate();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiQualityAuditCreate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

try {
    $api_instance->apiQualityAuditCreate();
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiQualityAuditCreate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();

eval { 
    $api_instance->apiQualityAuditCreate();
};
if ($@) {
    warn "Exception when calling ApiApi->apiQualityAuditCreate: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()

try: 
    api_instance.api_quality_audit_create()
except ApiException as e:
    print("Exception when calling ApiApi->apiQualityAuditCreate: %s\n" % e)

Parameters

Responses

Status: 201 -

apiQualityIncidentsBulkCompleteCreate

/api/quality/incidents/bulk-complete/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/quality/incidents/bulk-complete/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

import java.io.File;
import java.util.*;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiQualityIncidentsBulkCompleteCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiQualityIncidentsBulkCompleteCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiQualityIncidentsBulkCompleteCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiQualityIncidentsBulkCompleteCreate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


ApiApi *apiInstance = [[ApiApi alloc] init];

[apiInstance apiQualityIncidentsBulkCompleteCreateWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiQualityIncidentsBulkCompleteCreate(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiQualityIncidentsBulkCompleteCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                apiInstance.apiQualityIncidentsBulkCompleteCreate();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiQualityIncidentsBulkCompleteCreate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

try {
    $api_instance->apiQualityIncidentsBulkCompleteCreate();
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiQualityIncidentsBulkCompleteCreate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();

eval { 
    $api_instance->apiQualityIncidentsBulkCompleteCreate();
};
if ($@) {
    warn "Exception when calling ApiApi->apiQualityIncidentsBulkCompleteCreate: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()

try: 
    api_instance.api_quality_incidents_bulk_complete_create()
except ApiException as e:
    print("Exception when calling ApiApi->apiQualityIncidentsBulkCompleteCreate: %s\n" % e)

Parameters

Responses

Status: 201 -

apiSage200RecipesCreate

Checks relevant directories and inserts data into database.

/api/sage200/recipes/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/sage200/recipes/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

import java.io.File;
import java.util.*;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiSage200RecipesCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiSage200RecipesCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiSage200RecipesCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiSage200RecipesCreate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


ApiApi *apiInstance = [[ApiApi alloc] init];

[apiInstance apiSage200RecipesCreateWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiSage200RecipesCreate(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiSage200RecipesCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                apiInstance.apiSage200RecipesCreate();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiSage200RecipesCreate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

try {
    $api_instance->apiSage200RecipesCreate();
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiSage200RecipesCreate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();

eval { 
    $api_instance->apiSage200RecipesCreate();
};
if ($@) {
    warn "Exception when calling ApiApi->apiSage200RecipesCreate: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()

try: 
    api_instance.api_sage200_recipes_create()
except ApiException as e:
    print("Exception when calling ApiApi->apiSage200RecipesCreate: %s\n" % e)

Parameters

Responses

Status: 201 -

apiSage200StockCreate

Checks relevant directories and inserts data into database.

/api/sage200/stock/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/sage200/stock/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

import java.io.File;
import java.util.*;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiSage200StockCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiSage200StockCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiSage200StockCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiSage200StockCreate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


ApiApi *apiInstance = [[ApiApi alloc] init];

[apiInstance apiSage200StockCreateWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiSage200StockCreate(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiSage200StockCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                apiInstance.apiSage200StockCreate();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiSage200StockCreate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

try {
    $api_instance->apiSage200StockCreate();
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiSage200StockCreate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();

eval { 
    $api_instance->apiSage200StockCreate();
};
if ($@) {
    warn "Exception when calling ApiApi->apiSage200StockCreate: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()

try: 
    api_instance.api_sage200_stock_create()
except ApiException as e:
    print("Exception when calling ApiApi->apiSage200StockCreate: %s\n" % e)

Parameters

Responses

Status: 201 -

apiSage200WorkorderGetWorkOrdersList

/api/sage200/workorder/GetWorkOrders/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/sage200/workorder/GetWorkOrders/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

import java.io.File;
import java.util.*;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiSage200WorkorderGetWorkOrdersList();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiSage200WorkorderGetWorkOrdersList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiSage200WorkorderGetWorkOrdersList();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiSage200WorkorderGetWorkOrdersList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


ApiApi *apiInstance = [[ApiApi alloc] init];

[apiInstance apiSage200WorkorderGetWorkOrdersListWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiSage200WorkorderGetWorkOrdersList(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiSage200WorkorderGetWorkOrdersListExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                apiInstance.apiSage200WorkorderGetWorkOrdersList();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiSage200WorkorderGetWorkOrdersList: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

try {
    $api_instance->apiSage200WorkorderGetWorkOrdersList();
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiSage200WorkorderGetWorkOrdersList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();

eval { 
    $api_instance->apiSage200WorkorderGetWorkOrdersList();
};
if ($@) {
    warn "Exception when calling ApiApi->apiSage200WorkorderGetWorkOrdersList: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()

try: 
    api_instance.api_sage200_workorder_get_work_orders_list()
except ApiException as e:
    print("Exception when calling ApiApi->apiSage200WorkorderGetWorkOrdersList: %s\n" % e)

Parameters

Responses

Status: 200 -

apiSage200WorkorderheaderCreate

Checks relevant directories and inserts data into the database.

/api/sage200/workorderheader/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/sage200/workorderheader/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

import java.io.File;
import java.util.*;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiSage200WorkorderheaderCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiSage200WorkorderheaderCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiSage200WorkorderheaderCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiSage200WorkorderheaderCreate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


ApiApi *apiInstance = [[ApiApi alloc] init];

[apiInstance apiSage200WorkorderheaderCreateWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiSage200WorkorderheaderCreate(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiSage200WorkorderheaderCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                apiInstance.apiSage200WorkorderheaderCreate();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiSage200WorkorderheaderCreate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

try {
    $api_instance->apiSage200WorkorderheaderCreate();
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiSage200WorkorderheaderCreate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();

eval { 
    $api_instance->apiSage200WorkorderheaderCreate();
};
if ($@) {
    warn "Exception when calling ApiApi->apiSage200WorkorderheaderCreate: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()

try: 
    api_instance.api_sage200_workorderheader_create()
except ApiException as e:
    print("Exception when calling ApiApi->apiSage200WorkorderheaderCreate: %s\n" % e)

Parameters

Responses

Status: 201 -

apiStockDetailCreate

/api/stock/detail

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/stock/detail"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

import java.io.File;
import java.util.*;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        StockHDR data = ; // StockHDR | 
        try {
            StockHDR result = apiInstance.apiStockDetailCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiStockDetailCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        StockHDR data = ; // StockHDR | 
        try {
            StockHDR result = apiInstance.apiStockDetailCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiStockDetailCreate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

StockHDR *data = ; // 

ApiApi *apiInstance = [[ApiApi alloc] init];

[apiInstance apiStockDetailCreateWith:data
              completionHandler: ^(StockHDR output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var data = ; // {StockHDR} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiStockDetailCreate(data, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiStockDetailCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var data = new StockHDR(); // StockHDR | 

            try
            {
                StockHDR result = apiInstance.apiStockDetailCreate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiStockDetailCreate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$data = ; // StockHDR | 

try {
    $result = $api_instance->apiStockDetailCreate($data);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiStockDetailCreate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $data = WWW::SwaggerClient::Object::StockHDR->new(); # StockHDR | 

eval { 
    my $result = $api_instance->apiStockDetailCreate(data => $data);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiApi->apiStockDetailCreate: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
data =  # StockHDR | 

try: 
    api_response = api_instance.api_stock_detail_create(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiStockDetailCreate: %s\n" % e)

Parameters

Body parameters

Name	Description
data *

Responses

Status: 201 -

Schema

apiStockDetailList

/api/stock/detail

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/stock/detail?page="

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

import java.io.File;
import java.util.*;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        Integer page = 56; // Integer | A page number within the paginated result set.
        try {
            inline_response_200_6 result = apiInstance.apiStockDetailList(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiStockDetailList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Integer page = 56; // Integer | A page number within the paginated result set.
        try {
            inline_response_200_6 result = apiInstance.apiStockDetailList(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiStockDetailList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *page = 56; // A page number within the paginated result set. (optional)

ApiApi *apiInstance = [[ApiApi alloc] init];

[apiInstance apiStockDetailListWith:page
              completionHandler: ^(inline_response_200_6 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var opts = { 
  'page': 56 // {Integer} A page number within the paginated result set.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiStockDetailList(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiStockDetailListExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var page = 56;  // Integer | A page number within the paginated result set. (optional) 

            try
            {
                inline_response_200_6 result = apiInstance.apiStockDetailList(page);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiStockDetailList: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$page = 56; // Integer | A page number within the paginated result set.

try {
    $result = $api_instance->apiStockDetailList($page);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiStockDetailList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $page = 56; # Integer | A page number within the paginated result set.

eval { 
    my $result = $api_instance->apiStockDetailList(page => $page);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiApi->apiStockDetailList: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
page = 56 # Integer | A page number within the paginated result set. (optional)

try: 
    api_response = api_instance.api_stock_detail_list(page=page)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiStockDetailList: %s\n" % e)

Parameters

Query parameters

Name	Description
page	Integer A page number within the paginated result set.

Responses

Status: 200 -

Schema

apiStockStockdetCreate

/api/stock/stockdet/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/stock/stockdet/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

import java.io.File;
import java.util.*;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiStockStockdetCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiStockStockdetCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiStockStockdetCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiStockStockdetCreate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


ApiApi *apiInstance = [[ApiApi alloc] init];

[apiInstance apiStockStockdetCreateWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiStockStockdetCreate(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiStockStockdetCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                apiInstance.apiStockStockdetCreate();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiStockStockdetCreate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

try {
    $api_instance->apiStockStockdetCreate();
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiStockStockdetCreate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();

eval { 
    $api_instance->apiStockStockdetCreate();
};
if ($@) {
    warn "Exception when calling ApiApi->apiStockStockdetCreate: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()

try: 
    api_instance.api_stock_stockdet_create()
except ApiException as e:
    print("Exception when calling ApiApi->apiStockStockdetCreate: %s\n" % e)

Parameters

Responses

Status: 201 -

apiStockStockdetList

/api/stock/stockdet/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/stock/stockdet/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

import java.io.File;
import java.util.*;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiStockStockdetList();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiStockStockdetList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiStockStockdetList();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiStockStockdetList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


ApiApi *apiInstance = [[ApiApi alloc] init];

[apiInstance apiStockStockdetListWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiStockStockdetList(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiStockStockdetListExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                apiInstance.apiStockStockdetList();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiStockStockdetList: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

try {
    $api_instance->apiStockStockdetList();
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiStockStockdetList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();

eval { 
    $api_instance->apiStockStockdetList();
};
if ($@) {
    warn "Exception when calling ApiApi->apiStockStockdetList: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()

try: 
    api_instance.api_stock_stockdet_list()
except ApiException as e:
    print("Exception when calling ApiApi->apiStockStockdetList: %s\n" % e)

Parameters

Responses

Status: 200 -

apiStockStockhdrList

/api/stock/stockhdr/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/stock/stockhdr/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

import java.io.File;
import java.util.*;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            array[StockHDR] result = apiInstance.apiStockStockhdrList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiStockStockhdrList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            array[StockHDR] result = apiInstance.apiStockStockhdrList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiStockStockhdrList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


ApiApi *apiInstance = [[ApiApi alloc] init];

[apiInstance apiStockStockhdrListWithCompletionHandler: 
              ^(array[StockHDR] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiStockStockhdrList(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiStockStockhdrListExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                array[StockHDR] result = apiInstance.apiStockStockhdrList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiStockStockhdrList: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

try {
    $result = $api_instance->apiStockStockhdrList();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiStockStockhdrList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();

eval { 
    my $result = $api_instance->apiStockStockhdrList();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiApi->apiStockStockhdrList: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()

try: 
    api_response = api_instance.api_stock_stockhdr_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiStockStockhdrList: %s\n" % e)

Parameters

Responses

Status: 200 -

Schema

apiTokenCreate

Takes a set of user credentials and returns an access and refresh JSON web token pair to prove the authentication of those credentials.

/api/token/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/token/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

import java.io.File;
import java.util.*;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        TokenObtainPair data = ; // TokenObtainPair | 
        try {
            TokenObtainPair result = apiInstance.apiTokenCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiTokenCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        TokenObtainPair data = ; // TokenObtainPair | 
        try {
            TokenObtainPair result = apiInstance.apiTokenCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiTokenCreate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

TokenObtainPair *data = ; // 

ApiApi *apiInstance = [[ApiApi alloc] init];

[apiInstance apiTokenCreateWith:data
              completionHandler: ^(TokenObtainPair output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var data = ; // {TokenObtainPair} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiTokenCreate(data, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiTokenCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var data = new TokenObtainPair(); // TokenObtainPair | 

            try
            {
                TokenObtainPair result = apiInstance.apiTokenCreate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiTokenCreate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$data = ; // TokenObtainPair | 

try {
    $result = $api_instance->apiTokenCreate($data);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiTokenCreate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $data = WWW::SwaggerClient::Object::TokenObtainPair->new(); # TokenObtainPair | 

eval { 
    my $result = $api_instance->apiTokenCreate(data => $data);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiApi->apiTokenCreate: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
data =  # TokenObtainPair | 

try: 
    api_response = api_instance.api_token_create(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiTokenCreate: %s\n" % e)

Parameters

Body parameters

Name	Description
data *

Responses

Status: 201 -

Schema

apiTokenRefreshCreate

Takes a refresh type JSON web token and returns an access type JSON web token if the refresh token is valid.

/api/token/refresh/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/token/refresh/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

import java.io.File;
import java.util.*;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        TokenRefresh data = ; // TokenRefresh | 
        try {
            TokenRefresh result = apiInstance.apiTokenRefreshCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiTokenRefreshCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        TokenRefresh data = ; // TokenRefresh | 
        try {
            TokenRefresh result = apiInstance.apiTokenRefreshCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiTokenRefreshCreate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

TokenRefresh *data = ; // 

ApiApi *apiInstance = [[ApiApi alloc] init];

[apiInstance apiTokenRefreshCreateWith:data
              completionHandler: ^(TokenRefresh output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var data = ; // {TokenRefresh} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiTokenRefreshCreate(data, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiTokenRefreshCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var data = new TokenRefresh(); // TokenRefresh | 

            try
            {
                TokenRefresh result = apiInstance.apiTokenRefreshCreate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiTokenRefreshCreate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$data = ; // TokenRefresh | 

try {
    $result = $api_instance->apiTokenRefreshCreate($data);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiTokenRefreshCreate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $data = WWW::SwaggerClient::Object::TokenRefresh->new(); # TokenRefresh | 

eval { 
    my $result = $api_instance->apiTokenRefreshCreate(data => $data);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiApi->apiTokenRefreshCreate: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
data =  # TokenRefresh | 

try: 
    api_response = api_instance.api_token_refresh_create(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiTokenRefreshCreate: %s\n" % e)

Parameters

Body parameters

Name	Description
data *

Responses

Status: 201 -

Schema

apiUsersUserInfoPartialUpdate

/api/users/user-info/

Usage and SDK Samples

curl -X PATCH -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/users/user-info/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

import java.io.File;
import java.util.*;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        GetUser data = ; // GetUser | 
        try {
            GetUser result = apiInstance.apiUsersUserInfoPartialUpdate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiUsersUserInfoPartialUpdate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        GetUser data = ; // GetUser | 
        try {
            GetUser result = apiInstance.apiUsersUserInfoPartialUpdate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiUsersUserInfoPartialUpdate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

GetUser *data = ; // 

ApiApi *apiInstance = [[ApiApi alloc] init];

[apiInstance apiUsersUserInfoPartialUpdateWith:data
              completionHandler: ^(GetUser output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var data = ; // {GetUser} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiUsersUserInfoPartialUpdate(data, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiUsersUserInfoPartialUpdateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var data = new GetUser(); // GetUser | 

            try
            {
                GetUser result = apiInstance.apiUsersUserInfoPartialUpdate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiUsersUserInfoPartialUpdate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$data = ; // GetUser | 

try {
    $result = $api_instance->apiUsersUserInfoPartialUpdate($data);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiUsersUserInfoPartialUpdate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $data = WWW::SwaggerClient::Object::GetUser->new(); # GetUser | 

eval { 
    my $result = $api_instance->apiUsersUserInfoPartialUpdate(data => $data);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiApi->apiUsersUserInfoPartialUpdate: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
data =  # GetUser | 

try: 
    api_response = api_instance.api_users_user_info_partial_update(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiUsersUserInfoPartialUpdate: %s\n" % e)

Parameters

Body parameters

Name	Description
data *

Responses

Status: 200 -

Schema

apiUsersUserInfoRead

/api/users/user-info/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/users/user-info/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

import java.io.File;
import java.util.*;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            GetUser result = apiInstance.apiUsersUserInfoRead();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiUsersUserInfoRead");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            GetUser result = apiInstance.apiUsersUserInfoRead();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiUsersUserInfoRead");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


ApiApi *apiInstance = [[ApiApi alloc] init];

[apiInstance apiUsersUserInfoReadWithCompletionHandler: 
              ^(GetUser output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiUsersUserInfoRead(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiUsersUserInfoReadExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                GetUser result = apiInstance.apiUsersUserInfoRead();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiUsersUserInfoRead: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();

try {
    $result = $api_instance->apiUsersUserInfoRead();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiUsersUserInfoRead: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();

eval { 
    my $result = $api_instance->apiUsersUserInfoRead();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiApi->apiUsersUserInfoRead: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()

try: 
    api_response = api_instance.api_users_user_info_read()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiUsersUserInfoRead: %s\n" % e)

Parameters

Responses

Status: 200 -

Schema

apiUsersUserInfoUpdate

/api/users/user-info/

Usage and SDK Samples

curl -X PUT -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/users/user-info/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

import java.io.File;
import java.util.*;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        GetUser data = ; // GetUser | 
        try {
            GetUser result = apiInstance.apiUsersUserInfoUpdate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiUsersUserInfoUpdate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        GetUser data = ; // GetUser | 
        try {
            GetUser result = apiInstance.apiUsersUserInfoUpdate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiUsersUserInfoUpdate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

GetUser *data = ; // 

ApiApi *apiInstance = [[ApiApi alloc] init];

[apiInstance apiUsersUserInfoUpdateWith:data
              completionHandler: ^(GetUser output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var data = ; // {GetUser} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiUsersUserInfoUpdate(data, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiUsersUserInfoUpdateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var data = new GetUser(); // GetUser | 

            try
            {
                GetUser result = apiInstance.apiUsersUserInfoUpdate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiUsersUserInfoUpdate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$data = ; // GetUser | 

try {
    $result = $api_instance->apiUsersUserInfoUpdate($data);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ApiApi->apiUsersUserInfoUpdate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $data = WWW::SwaggerClient::Object::GetUser->new(); # GetUser | 

eval { 
    my $result = $api_instance->apiUsersUserInfoUpdate(data => $data);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiApi->apiUsersUserInfoUpdate: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
data =  # GetUser | 

try: 
    api_response = api_instance.api_users_user_info_update(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiUsersUserInfoUpdate: %s\n" % e)

Parameters

Body parameters

Name	Description
data *

Responses

Status: 200 -

Schema

DjRestAuth

djRestAuthLoginCreate

Check the credentials and return the REST Token if the credentials are valid and authenticated. Calls Django Auth login method to register User ID in Django session framework Accept the following POST parameters: username, password Return the REST Framework Token Object's key.

/dj-rest-auth/login/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/dj-rest-auth/login/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DjRestAuthApi;

import java.io.File;
import java.util.*;

public class DjRestAuthApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        DjRestAuthApi apiInstance = new DjRestAuthApi();
        Login data = ; // Login | 
        try {
            Login result = apiInstance.djRestAuthLoginCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DjRestAuthApi#djRestAuthLoginCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DjRestAuthApi;

public class DjRestAuthApiExample {

    public static void main(String[] args) {
        DjRestAuthApi apiInstance = new DjRestAuthApi();
        Login data = ; // Login | 
        try {
            Login result = apiInstance.djRestAuthLoginCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DjRestAuthApi#djRestAuthLoginCreate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Login *data = ; // 

DjRestAuthApi *apiInstance = [[DjRestAuthApi alloc] init];

[apiInstance djRestAuthLoginCreateWith:data
              completionHandler: ^(Login output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.DjRestAuthApi()

var data = ; // {Login} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.djRestAuthLoginCreate(data, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class djRestAuthLoginCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DjRestAuthApi();
            var data = new Login(); // Login | 

            try
            {
                Login result = apiInstance.djRestAuthLoginCreate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DjRestAuthApi.djRestAuthLoginCreate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DjRestAuthApi();
$data = ; // Login | 

try {
    $result = $api_instance->djRestAuthLoginCreate($data);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DjRestAuthApi->djRestAuthLoginCreate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DjRestAuthApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DjRestAuthApi->new();
my $data = WWW::SwaggerClient::Object::Login->new(); # Login | 

eval { 
    my $result = $api_instance->djRestAuthLoginCreate(data => $data);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DjRestAuthApi->djRestAuthLoginCreate: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DjRestAuthApi()
data =  # Login | 

try: 
    api_response = api_instance.dj_rest_auth_login_create(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DjRestAuthApi->djRestAuthLoginCreate: %s\n" % e)

Parameters

Body parameters

Name	Description
data *

Responses

Status: 201 -

Schema

djRestAuthLogoutCreate

Calls Django logout method and delete the Token object assigned to the current User object.

Accepts/Returns nothing.

/dj-rest-auth/logout/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/dj-rest-auth/logout/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DjRestAuthApi;

import java.io.File;
import java.util.*;

public class DjRestAuthApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        DjRestAuthApi apiInstance = new DjRestAuthApi();
        try {
            apiInstance.djRestAuthLogoutCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling DjRestAuthApi#djRestAuthLogoutCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DjRestAuthApi;

public class DjRestAuthApiExample {

    public static void main(String[] args) {
        DjRestAuthApi apiInstance = new DjRestAuthApi();
        try {
            apiInstance.djRestAuthLogoutCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling DjRestAuthApi#djRestAuthLogoutCreate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


DjRestAuthApi *apiInstance = [[DjRestAuthApi alloc] init];

// Calls Django logout method and delete the Token object
assigned to the current User object.
[apiInstance djRestAuthLogoutCreateWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.DjRestAuthApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.djRestAuthLogoutCreate(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class djRestAuthLogoutCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DjRestAuthApi();

            try
            {
                // Calls Django logout method and delete the Token object
assigned to the current User object.
                apiInstance.djRestAuthLogoutCreate();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DjRestAuthApi.djRestAuthLogoutCreate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DjRestAuthApi();

try {
    $api_instance->djRestAuthLogoutCreate();
} catch (Exception $e) {
    echo 'Exception when calling DjRestAuthApi->djRestAuthLogoutCreate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DjRestAuthApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DjRestAuthApi->new();

eval { 
    $api_instance->djRestAuthLogoutCreate();
};
if ($@) {
    warn "Exception when calling DjRestAuthApi->djRestAuthLogoutCreate: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DjRestAuthApi()

try: 
    # Calls Django logout method and delete the Token object
assigned to the current User object.
    api_instance.dj_rest_auth_logout_create()
except ApiException as e:
    print("Exception when calling DjRestAuthApi->djRestAuthLogoutCreate: %s\n" % e)

Parameters

Responses

Status: 201 -

djRestAuthLogoutList

Calls Django logout method and delete the Token object assigned to the current User object.

Accepts/Returns nothing.

/dj-rest-auth/logout/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/dj-rest-auth/logout/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DjRestAuthApi;

import java.io.File;
import java.util.*;

public class DjRestAuthApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        DjRestAuthApi apiInstance = new DjRestAuthApi();
        try {
            apiInstance.djRestAuthLogoutList();
        } catch (ApiException e) {
            System.err.println("Exception when calling DjRestAuthApi#djRestAuthLogoutList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DjRestAuthApi;

public class DjRestAuthApiExample {

    public static void main(String[] args) {
        DjRestAuthApi apiInstance = new DjRestAuthApi();
        try {
            apiInstance.djRestAuthLogoutList();
        } catch (ApiException e) {
            System.err.println("Exception when calling DjRestAuthApi#djRestAuthLogoutList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


DjRestAuthApi *apiInstance = [[DjRestAuthApi alloc] init];

// Calls Django logout method and delete the Token object
assigned to the current User object.
[apiInstance djRestAuthLogoutListWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.DjRestAuthApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.djRestAuthLogoutList(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class djRestAuthLogoutListExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DjRestAuthApi();

            try
            {
                // Calls Django logout method and delete the Token object
assigned to the current User object.
                apiInstance.djRestAuthLogoutList();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DjRestAuthApi.djRestAuthLogoutList: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DjRestAuthApi();

try {
    $api_instance->djRestAuthLogoutList();
} catch (Exception $e) {
    echo 'Exception when calling DjRestAuthApi->djRestAuthLogoutList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DjRestAuthApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DjRestAuthApi->new();

eval { 
    $api_instance->djRestAuthLogoutList();
};
if ($@) {
    warn "Exception when calling DjRestAuthApi->djRestAuthLogoutList: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DjRestAuthApi()

try: 
    # Calls Django logout method and delete the Token object
assigned to the current User object.
    api_instance.dj_rest_auth_logout_list()
except ApiException as e:
    print("Exception when calling DjRestAuthApi->djRestAuthLogoutList: %s\n" % e)

Parameters

Responses

Status: 200 -

djRestAuthPasswordChangeCreate

Calls Django Auth SetPasswordForm save method.

Accepts the following POST parameters: new_password1, new_password2 Returns the success/fail message.

/dj-rest-auth/password/change/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/dj-rest-auth/password/change/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DjRestAuthApi;

import java.io.File;
import java.util.*;

public class DjRestAuthApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        DjRestAuthApi apiInstance = new DjRestAuthApi();
        PasswordChange data = ; // PasswordChange | 
        try {
            PasswordChange result = apiInstance.djRestAuthPasswordChangeCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DjRestAuthApi#djRestAuthPasswordChangeCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DjRestAuthApi;

public class DjRestAuthApiExample {

    public static void main(String[] args) {
        DjRestAuthApi apiInstance = new DjRestAuthApi();
        PasswordChange data = ; // PasswordChange | 
        try {
            PasswordChange result = apiInstance.djRestAuthPasswordChangeCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DjRestAuthApi#djRestAuthPasswordChangeCreate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

PasswordChange *data = ; // 

DjRestAuthApi *apiInstance = [[DjRestAuthApi alloc] init];

// Calls Django Auth SetPasswordForm save method.
[apiInstance djRestAuthPasswordChangeCreateWith:data
              completionHandler: ^(PasswordChange output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.DjRestAuthApi()

var data = ; // {PasswordChange} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.djRestAuthPasswordChangeCreate(data, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class djRestAuthPasswordChangeCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DjRestAuthApi();
            var data = new PasswordChange(); // PasswordChange | 

            try
            {
                // Calls Django Auth SetPasswordForm save method.
                PasswordChange result = apiInstance.djRestAuthPasswordChangeCreate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DjRestAuthApi.djRestAuthPasswordChangeCreate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DjRestAuthApi();
$data = ; // PasswordChange | 

try {
    $result = $api_instance->djRestAuthPasswordChangeCreate($data);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DjRestAuthApi->djRestAuthPasswordChangeCreate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DjRestAuthApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DjRestAuthApi->new();
my $data = WWW::SwaggerClient::Object::PasswordChange->new(); # PasswordChange | 

eval { 
    my $result = $api_instance->djRestAuthPasswordChangeCreate(data => $data);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DjRestAuthApi->djRestAuthPasswordChangeCreate: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DjRestAuthApi()
data =  # PasswordChange | 

try: 
    # Calls Django Auth SetPasswordForm save method.
    api_response = api_instance.dj_rest_auth_password_change_create(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DjRestAuthApi->djRestAuthPasswordChangeCreate: %s\n" % e)

Parameters

Body parameters

Name	Description
data *

Responses

Status: 201 -

Schema

djRestAuthPasswordResetConfirmCreate

Password reset e-mail link is confirmed, therefore this resets the user's password.

Accepts the following POST parameters: token, uid, new_password1, new_password2 Returns the success/fail message.

/dj-rest-auth/password/reset/confirm/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/dj-rest-auth/password/reset/confirm/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DjRestAuthApi;

import java.io.File;
import java.util.*;

public class DjRestAuthApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        DjRestAuthApi apiInstance = new DjRestAuthApi();
        PasswordResetConfirm data = ; // PasswordResetConfirm | 
        try {
            PasswordResetConfirm result = apiInstance.djRestAuthPasswordResetConfirmCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DjRestAuthApi#djRestAuthPasswordResetConfirmCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DjRestAuthApi;

public class DjRestAuthApiExample {

    public static void main(String[] args) {
        DjRestAuthApi apiInstance = new DjRestAuthApi();
        PasswordResetConfirm data = ; // PasswordResetConfirm | 
        try {
            PasswordResetConfirm result = apiInstance.djRestAuthPasswordResetConfirmCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DjRestAuthApi#djRestAuthPasswordResetConfirmCreate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

PasswordResetConfirm *data = ; // 

DjRestAuthApi *apiInstance = [[DjRestAuthApi alloc] init];

// Password reset e-mail link is confirmed, therefore
this resets the user's password.
[apiInstance djRestAuthPasswordResetConfirmCreateWith:data
              completionHandler: ^(PasswordResetConfirm output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.DjRestAuthApi()

var data = ; // {PasswordResetConfirm} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.djRestAuthPasswordResetConfirmCreate(data, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class djRestAuthPasswordResetConfirmCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DjRestAuthApi();
            var data = new PasswordResetConfirm(); // PasswordResetConfirm | 

            try
            {
                // Password reset e-mail link is confirmed, therefore
this resets the user's password.
                PasswordResetConfirm result = apiInstance.djRestAuthPasswordResetConfirmCreate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DjRestAuthApi.djRestAuthPasswordResetConfirmCreate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DjRestAuthApi();
$data = ; // PasswordResetConfirm | 

try {
    $result = $api_instance->djRestAuthPasswordResetConfirmCreate($data);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DjRestAuthApi->djRestAuthPasswordResetConfirmCreate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DjRestAuthApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DjRestAuthApi->new();
my $data = WWW::SwaggerClient::Object::PasswordResetConfirm->new(); # PasswordResetConfirm | 

eval { 
    my $result = $api_instance->djRestAuthPasswordResetConfirmCreate(data => $data);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DjRestAuthApi->djRestAuthPasswordResetConfirmCreate: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DjRestAuthApi()
data =  # PasswordResetConfirm | 

try: 
    # Password reset e-mail link is confirmed, therefore
this resets the user's password.
    api_response = api_instance.dj_rest_auth_password_reset_confirm_create(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DjRestAuthApi->djRestAuthPasswordResetConfirmCreate: %s\n" % e)

Parameters

Body parameters

Name	Description
data *

Responses

Status: 201 -

Schema

djRestAuthPasswordResetCreate

Calls Django Auth PasswordResetForm save method.

Accepts the following POST parameters: email Returns the success/fail message.

/dj-rest-auth/password/reset/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/dj-rest-auth/password/reset/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DjRestAuthApi;

import java.io.File;
import java.util.*;

public class DjRestAuthApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        DjRestAuthApi apiInstance = new DjRestAuthApi();
        PasswordReset data = ; // PasswordReset | 
        try {
            PasswordReset result = apiInstance.djRestAuthPasswordResetCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DjRestAuthApi#djRestAuthPasswordResetCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DjRestAuthApi;

public class DjRestAuthApiExample {

    public static void main(String[] args) {
        DjRestAuthApi apiInstance = new DjRestAuthApi();
        PasswordReset data = ; // PasswordReset | 
        try {
            PasswordReset result = apiInstance.djRestAuthPasswordResetCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DjRestAuthApi#djRestAuthPasswordResetCreate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

PasswordReset *data = ; // 

DjRestAuthApi *apiInstance = [[DjRestAuthApi alloc] init];

// Calls Django Auth PasswordResetForm save method.
[apiInstance djRestAuthPasswordResetCreateWith:data
              completionHandler: ^(PasswordReset output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.DjRestAuthApi()

var data = ; // {PasswordReset} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.djRestAuthPasswordResetCreate(data, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class djRestAuthPasswordResetCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DjRestAuthApi();
            var data = new PasswordReset(); // PasswordReset | 

            try
            {
                // Calls Django Auth PasswordResetForm save method.
                PasswordReset result = apiInstance.djRestAuthPasswordResetCreate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DjRestAuthApi.djRestAuthPasswordResetCreate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DjRestAuthApi();
$data = ; // PasswordReset | 

try {
    $result = $api_instance->djRestAuthPasswordResetCreate($data);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DjRestAuthApi->djRestAuthPasswordResetCreate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DjRestAuthApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DjRestAuthApi->new();
my $data = WWW::SwaggerClient::Object::PasswordReset->new(); # PasswordReset | 

eval { 
    my $result = $api_instance->djRestAuthPasswordResetCreate(data => $data);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DjRestAuthApi->djRestAuthPasswordResetCreate: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DjRestAuthApi()
data =  # PasswordReset | 

try: 
    # Calls Django Auth PasswordResetForm save method.
    api_response = api_instance.dj_rest_auth_password_reset_create(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DjRestAuthApi->djRestAuthPasswordResetCreate: %s\n" % e)

Parameters

Body parameters

Name	Description
data *

Responses

Status: 201 -

Schema

djRestAuthTokenRefreshCreate

/dj-rest-auth/token/refresh/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/dj-rest-auth/token/refresh/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DjRestAuthApi;

import java.io.File;
import java.util.*;

public class DjRestAuthApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        DjRestAuthApi apiInstance = new DjRestAuthApi();
        CookieTokenRefresh data = ; // CookieTokenRefresh | 
        try {
            CookieTokenRefresh result = apiInstance.djRestAuthTokenRefreshCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DjRestAuthApi#djRestAuthTokenRefreshCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DjRestAuthApi;

public class DjRestAuthApiExample {

    public static void main(String[] args) {
        DjRestAuthApi apiInstance = new DjRestAuthApi();
        CookieTokenRefresh data = ; // CookieTokenRefresh | 
        try {
            CookieTokenRefresh result = apiInstance.djRestAuthTokenRefreshCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DjRestAuthApi#djRestAuthTokenRefreshCreate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

CookieTokenRefresh *data = ; // 

DjRestAuthApi *apiInstance = [[DjRestAuthApi alloc] init];

[apiInstance djRestAuthTokenRefreshCreateWith:data
              completionHandler: ^(CookieTokenRefresh output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.DjRestAuthApi()

var data = ; // {CookieTokenRefresh} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.djRestAuthTokenRefreshCreate(data, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class djRestAuthTokenRefreshCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DjRestAuthApi();
            var data = new CookieTokenRefresh(); // CookieTokenRefresh | 

            try
            {
                CookieTokenRefresh result = apiInstance.djRestAuthTokenRefreshCreate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DjRestAuthApi.djRestAuthTokenRefreshCreate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DjRestAuthApi();
$data = ; // CookieTokenRefresh | 

try {
    $result = $api_instance->djRestAuthTokenRefreshCreate($data);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DjRestAuthApi->djRestAuthTokenRefreshCreate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DjRestAuthApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DjRestAuthApi->new();
my $data = WWW::SwaggerClient::Object::CookieTokenRefresh->new(); # CookieTokenRefresh | 

eval { 
    my $result = $api_instance->djRestAuthTokenRefreshCreate(data => $data);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DjRestAuthApi->djRestAuthTokenRefreshCreate: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DjRestAuthApi()
data =  # CookieTokenRefresh | 

try: 
    api_response = api_instance.dj_rest_auth_token_refresh_create(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DjRestAuthApi->djRestAuthTokenRefreshCreate: %s\n" % e)

Parameters

Body parameters

Name	Description
data *

Responses

Status: 201 -

Schema

djRestAuthTokenVerifyCreate

Takes a token and indicates if it is valid. This view provides no information about a token's fitness for a particular use.

/dj-rest-auth/token/verify/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/dj-rest-auth/token/verify/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DjRestAuthApi;

import java.io.File;
import java.util.*;

public class DjRestAuthApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        DjRestAuthApi apiInstance = new DjRestAuthApi();
        TokenVerify data = ; // TokenVerify | 
        try {
            TokenVerify result = apiInstance.djRestAuthTokenVerifyCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DjRestAuthApi#djRestAuthTokenVerifyCreate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DjRestAuthApi;

public class DjRestAuthApiExample {

    public static void main(String[] args) {
        DjRestAuthApi apiInstance = new DjRestAuthApi();
        TokenVerify data = ; // TokenVerify | 
        try {
            TokenVerify result = apiInstance.djRestAuthTokenVerifyCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DjRestAuthApi#djRestAuthTokenVerifyCreate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

TokenVerify *data = ; // 

DjRestAuthApi *apiInstance = [[DjRestAuthApi alloc] init];

[apiInstance djRestAuthTokenVerifyCreateWith:data
              completionHandler: ^(TokenVerify output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.DjRestAuthApi()

var data = ; // {TokenVerify} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.djRestAuthTokenVerifyCreate(data, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class djRestAuthTokenVerifyCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DjRestAuthApi();
            var data = new TokenVerify(); // TokenVerify | 

            try
            {
                TokenVerify result = apiInstance.djRestAuthTokenVerifyCreate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DjRestAuthApi.djRestAuthTokenVerifyCreate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DjRestAuthApi();
$data = ; // TokenVerify | 

try {
    $result = $api_instance->djRestAuthTokenVerifyCreate($data);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DjRestAuthApi->djRestAuthTokenVerifyCreate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DjRestAuthApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DjRestAuthApi->new();
my $data = WWW::SwaggerClient::Object::TokenVerify->new(); # TokenVerify | 

eval { 
    my $result = $api_instance->djRestAuthTokenVerifyCreate(data => $data);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DjRestAuthApi->djRestAuthTokenVerifyCreate: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DjRestAuthApi()
data =  # TokenVerify | 

try: 
    api_response = api_instance.dj_rest_auth_token_verify_create(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DjRestAuthApi->djRestAuthTokenVerifyCreate: %s\n" % e)

Parameters

Body parameters

Name	Description
data *

Responses

Status: 201 -

Schema

djRestAuthUserPartialUpdate

Reads and updates UserModel fields Accepts GET, PUT, PATCH methods.

Default accepted fields: username, first_name, last_name Default display fields: pk, username, email, first_name, last_name Read-only fields: pk, email Returns UserModel fields.

/dj-rest-auth/user/

Usage and SDK Samples

curl -X PATCH -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/dj-rest-auth/user/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DjRestAuthApi;

import java.io.File;
import java.util.*;

public class DjRestAuthApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        DjRestAuthApi apiInstance = new DjRestAuthApi();
        UserDetails data = ; // UserDetails | 
        try {
            UserDetails result = apiInstance.djRestAuthUserPartialUpdate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DjRestAuthApi#djRestAuthUserPartialUpdate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DjRestAuthApi;

public class DjRestAuthApiExample {

    public static void main(String[] args) {
        DjRestAuthApi apiInstance = new DjRestAuthApi();
        UserDetails data = ; // UserDetails | 
        try {
            UserDetails result = apiInstance.djRestAuthUserPartialUpdate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DjRestAuthApi#djRestAuthUserPartialUpdate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

UserDetails *data = ; // 

DjRestAuthApi *apiInstance = [[DjRestAuthApi alloc] init];

// Reads and updates UserModel fields
Accepts GET, PUT, PATCH methods.
[apiInstance djRestAuthUserPartialUpdateWith:data
              completionHandler: ^(UserDetails output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.DjRestAuthApi()

var data = ; // {UserDetails} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.djRestAuthUserPartialUpdate(data, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class djRestAuthUserPartialUpdateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DjRestAuthApi();
            var data = new UserDetails(); // UserDetails | 

            try
            {
                // Reads and updates UserModel fields
Accepts GET, PUT, PATCH methods.
                UserDetails result = apiInstance.djRestAuthUserPartialUpdate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DjRestAuthApi.djRestAuthUserPartialUpdate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DjRestAuthApi();
$data = ; // UserDetails | 

try {
    $result = $api_instance->djRestAuthUserPartialUpdate($data);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DjRestAuthApi->djRestAuthUserPartialUpdate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DjRestAuthApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DjRestAuthApi->new();
my $data = WWW::SwaggerClient::Object::UserDetails->new(); # UserDetails | 

eval { 
    my $result = $api_instance->djRestAuthUserPartialUpdate(data => $data);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DjRestAuthApi->djRestAuthUserPartialUpdate: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DjRestAuthApi()
data =  # UserDetails | 

try: 
    # Reads and updates UserModel fields
Accepts GET, PUT, PATCH methods.
    api_response = api_instance.dj_rest_auth_user_partial_update(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DjRestAuthApi->djRestAuthUserPartialUpdate: %s\n" % e)

Parameters

Body parameters

Name	Description
data *

Responses

Status: 200 -

Schema

djRestAuthUserRead

Reads and updates UserModel fields Accepts GET, PUT, PATCH methods.

Default accepted fields: username, first_name, last_name Default display fields: pk, username, email, first_name, last_name Read-only fields: pk, email Returns UserModel fields.

/dj-rest-auth/user/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/dj-rest-auth/user/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DjRestAuthApi;

import java.io.File;
import java.util.*;

public class DjRestAuthApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        DjRestAuthApi apiInstance = new DjRestAuthApi();
        try {
            UserDetails result = apiInstance.djRestAuthUserRead();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DjRestAuthApi#djRestAuthUserRead");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DjRestAuthApi;

public class DjRestAuthApiExample {

    public static void main(String[] args) {
        DjRestAuthApi apiInstance = new DjRestAuthApi();
        try {
            UserDetails result = apiInstance.djRestAuthUserRead();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DjRestAuthApi#djRestAuthUserRead");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


DjRestAuthApi *apiInstance = [[DjRestAuthApi alloc] init];

// Reads and updates UserModel fields
Accepts GET, PUT, PATCH methods.
[apiInstance djRestAuthUserReadWithCompletionHandler: 
              ^(UserDetails output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.DjRestAuthApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.djRestAuthUserRead(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class djRestAuthUserReadExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DjRestAuthApi();

            try
            {
                // Reads and updates UserModel fields
Accepts GET, PUT, PATCH methods.
                UserDetails result = apiInstance.djRestAuthUserRead();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DjRestAuthApi.djRestAuthUserRead: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DjRestAuthApi();

try {
    $result = $api_instance->djRestAuthUserRead();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DjRestAuthApi->djRestAuthUserRead: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DjRestAuthApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DjRestAuthApi->new();

eval { 
    my $result = $api_instance->djRestAuthUserRead();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DjRestAuthApi->djRestAuthUserRead: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DjRestAuthApi()

try: 
    # Reads and updates UserModel fields
Accepts GET, PUT, PATCH methods.
    api_response = api_instance.dj_rest_auth_user_read()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DjRestAuthApi->djRestAuthUserRead: %s\n" % e)

Parameters

Responses

Status: 200 -

Schema

djRestAuthUserUpdate

Reads and updates UserModel fields Accepts GET, PUT, PATCH methods.

Default accepted fields: username, first_name, last_name Default display fields: pk, username, email, first_name, last_name Read-only fields: pk, email Returns UserModel fields.

/dj-rest-auth/user/

Usage and SDK Samples

curl -X PUT -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/dj-rest-auth/user/"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DjRestAuthApi;

import java.io.File;
import java.util.*;

public class DjRestAuthApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        DjRestAuthApi apiInstance = new DjRestAuthApi();
        UserDetails data = ; // UserDetails | 
        try {
            UserDetails result = apiInstance.djRestAuthUserUpdate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DjRestAuthApi#djRestAuthUserUpdate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DjRestAuthApi;

public class DjRestAuthApiExample {

    public static void main(String[] args) {
        DjRestAuthApi apiInstance = new DjRestAuthApi();
        UserDetails data = ; // UserDetails | 
        try {
            UserDetails result = apiInstance.djRestAuthUserUpdate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DjRestAuthApi#djRestAuthUserUpdate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

UserDetails *data = ; // 

DjRestAuthApi *apiInstance = [[DjRestAuthApi alloc] init];

// Reads and updates UserModel fields
Accepts GET, PUT, PATCH methods.
[apiInstance djRestAuthUserUpdateWith:data
              completionHandler: ^(UserDetails output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.DjRestAuthApi()

var data = ; // {UserDetails} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.djRestAuthUserUpdate(data, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class djRestAuthUserUpdateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DjRestAuthApi();
            var data = new UserDetails(); // UserDetails | 

            try
            {
                // Reads and updates UserModel fields
Accepts GET, PUT, PATCH methods.
                UserDetails result = apiInstance.djRestAuthUserUpdate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DjRestAuthApi.djRestAuthUserUpdate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DjRestAuthApi();
$data = ; // UserDetails | 

try {
    $result = $api_instance->djRestAuthUserUpdate($data);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DjRestAuthApi->djRestAuthUserUpdate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DjRestAuthApi;

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DjRestAuthApi->new();
my $data = WWW::SwaggerClient::Object::UserDetails->new(); # UserDetails | 

eval { 
    my $result = $api_instance->djRestAuthUserUpdate(data => $data);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DjRestAuthApi->djRestAuthUserUpdate: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DjRestAuthApi()
data =  # UserDetails | 

try: 
    # Reads and updates UserModel fields
Accepts GET, PUT, PATCH methods.
    api_response = api_instance.dj_rest_auth_user_update(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DjRestAuthApi->djRestAuthUserUpdate: %s\n" % e)

Parameters

Body parameters

Name	Description
data *

Responses

Status: 200 -

Schema

Internal - TraceSense API

API and SDK Documentation

Api

apiAllergensListAllergensList

Usage and SDK Samples

Parameters

Responses

Status: 200 -

apiCommoditiesAddCsvCreate

Usage and SDK Samples

Parameters

Responses

Status: 201 -

apiCommoditiesCommoditiesCreate

Usage and SDK Samples

Parameters

Responses

Status: 201 -

apiCommoditiesCommoditiesList

Usage and SDK Samples

Parameters

Responses

Status: 200 -

apiCommoditiesListCommodityGroupsList

Usage and SDK Samples

Parameters

Responses

Status: 200 -

apiCommoditiesListList

Usage and SDK Samples

Parameters

Responses

Status: 200 -

apiCommoditiesListSuppliersList

Usage and SDK Samples

Parameters

Responses

Status: 200 -

apiCommoditiesSupplierAddCsvCreate

Usage and SDK Samples

Parameters

Responses

Status: 201 -

apiCommoditiesSupplierCreate

Usage and SDK Samples

Parameters

Responses

Status: 201 -

apiCommoditiesSupplierList

Usage and SDK Samples

Parameters

Responses

Status: 200 -

apiDispatchListCustomersList

Usage and SDK Samples

Parameters

Responses

Status: 200 -

apiDispatchListSalesOrdersList

Usage and SDK Samples

Parameters

Responses

Status: 200 -

apiDispatchSalesOrderDetailsList

Usage and SDK Samples

Parameters

Responses

Status: 200 -

apiDispatchV1SalesordersCreate

Usage and SDK Samples

Parameters

Responses

Status: 201 -

apiDocumentsUploadCreate

Usage and SDK Samples

Parameters

Responses

Status: 201 -

apiJobListHeadersList

Usage and SDK Samples