ScanPower API

Auth

getAccessToken

Get an access token from Amazon with which to make SP-API calls.


/api/az/access-token

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/access-token?marketplace=US"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AuthApi;

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

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

        // Create an instance of the API class
        AuthApi apiInstance = new AuthApi();
        String marketplace = US; // String | The marketplace to perform operations in.

        try {
            getAccessToken_200_response result = apiInstance.getAccessToken(marketplace);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#getAccessToken");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String marketplace = new String(); // String | The marketplace to perform operations in.

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

import org.openapitools.client.api.AuthApi;

public class AuthApiExample {
    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();
        String marketplace = US; // String | The marketplace to perform operations in.

        try {
            getAccessToken_200_response result = apiInstance.getAccessToken(marketplace);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#getAccessToken");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic_auth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AuthApi *apiInstance = [[AuthApi alloc] init];
String *marketplace = US; // The marketplace to perform operations in. (optional) (default to null)

[apiInstance getAccessTokenWith:marketplace
              completionHandler: ^(getAccessToken_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.AuthApi()
var opts = {
  'marketplace': US // {String} The marketplace to perform operations in.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAccessToken(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AuthApi();
            var marketplace = US;  // String | The marketplace to perform operations in. (optional)  (default to null)

            try {
                getAccessToken_200_response result = apiInstance.getAccessToken(marketplace);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthApi.getAccessToken: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basic_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthApi();
$marketplace = US; // String | The marketplace to perform operations in.

try {
    $result = $api_instance->getAccessToken($marketplace);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->getAccessToken: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AuthApi;
# Configure HTTP basic authorization: basic_auth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthApi->new();
my $marketplace = US; # String | The marketplace to perform operations in.

eval {
    my $result = $api_instance->getAccessToken(marketplace => $marketplace);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthApi->getAccessToken: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: basic_auth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AuthApi()
marketplace = US # String | The marketplace to perform operations in. (optional) (default to null)

try:
    api_response = api_instance.get_access_token(marketplace=marketplace)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthApi->getAccessToken: %s\n" % e)
extern crate AuthApi;

pub fn main() {
    let marketplace = US; // String

    let mut context = AuthApi::Context::default();
    let result = client.getAccessToken(marketplace, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
marketplace
String
The marketplace to perform operations in.

Responses


getApiToken

Generate an API token

All other API calls require the token that this endpoint provides


/api/v2/token

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: text/plain" \
 "https://unity.scanpower.com/api/v2/token"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AuthApi;

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

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

        // Create an instance of the API class
        AuthApi apiInstance = new AuthApi();
        String xProxy = xProxy_example; // String | The ID of a user you have proxy access to. If provided, the returned token will allow you to make API calls on behalf of this user.

        try {
            'String' result = apiInstance.getApiToken(xProxy);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#getApiToken");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String xProxy = new String(); // String | The ID of a user you have proxy access to. If provided, the returned token will allow you to make API calls on behalf of this user.

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

import org.openapitools.client.api.AuthApi;

public class AuthApiExample {
    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();
        String xProxy = xProxy_example; // String | The ID of a user you have proxy access to. If provided, the returned token will allow you to make API calls on behalf of this user.

        try {
            'String' result = apiInstance.getApiToken(xProxy);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#getApiToken");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic_auth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AuthApi *apiInstance = [[AuthApi alloc] init];
String *xProxy = xProxy_example; // The ID of a user you have proxy access to. If provided, the returned token will allow you to make API calls on behalf of this user. (optional) (default to null)

// Generate an API token
[apiInstance getApiTokenWith:xProxy
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.AuthApi()
var opts = {
  'xProxy': xProxy_example // {String} The ID of a user you have proxy access to. If provided, the returned token will allow you to make API calls on behalf of this user.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getApiToken(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AuthApi();
            var xProxy = xProxy_example;  // String | The ID of a user you have proxy access to. If provided, the returned token will allow you to make API calls on behalf of this user. (optional)  (default to null)

            try {
                // Generate an API token
                'String' result = apiInstance.getApiToken(xProxy);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthApi.getApiToken: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basic_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthApi();
$xProxy = xProxy_example; // String | The ID of a user you have proxy access to. If provided, the returned token will allow you to make API calls on behalf of this user.

try {
    $result = $api_instance->getApiToken($xProxy);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->getApiToken: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AuthApi;
# Configure HTTP basic authorization: basic_auth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthApi->new();
my $xProxy = xProxy_example; # String | The ID of a user you have proxy access to. If provided, the returned token will allow you to make API calls on behalf of this user.

eval {
    my $result = $api_instance->getApiToken(xProxy => $xProxy);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthApi->getApiToken: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: basic_auth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AuthApi()
xProxy = xProxy_example # String | The ID of a user you have proxy access to. If provided, the returned token will allow you to make API calls on behalf of this user. (optional) (default to null)

try:
    # Generate an API token
    api_response = api_instance.get_api_token(xProxy=xProxy)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthApi->getApiToken: %s\n" % e)
extern crate AuthApi;

pub fn main() {
    let xProxy = xProxy_example; // String

    let mut context = AuthApi::Context::default();
    let result = client.getApiToken(xProxy, &context).wait();

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

Scopes

Parameters

Header parameters
Name Description
X-Proxy
String
The ID of a user you have proxy access to. If provided, the returned token will allow you to make API calls on behalf of this user.

Responses


v1getApiToken

Generate an API token

All other API calls require the token that this endpoint provides


/list/boxt?token

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: text/plain" \
 "https://unity.scanpower.com/list/boxt?token"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AuthApi;

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

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

        // Create an instance of the API class
        AuthApi apiInstance = new AuthApi();
        String xProxy = xProxy_example; // String | The ID of a user you have proxy access to. If provided, the returned token will allow you to make API calls on behalf of this user.

        try {
            'String' result = apiInstance.v1getApiToken(xProxy);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#v1getApiToken");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String xProxy = new String(); // String | The ID of a user you have proxy access to. If provided, the returned token will allow you to make API calls on behalf of this user.

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

import org.openapitools.client.api.AuthApi;

public class AuthApiExample {
    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();
        String xProxy = xProxy_example; // String | The ID of a user you have proxy access to. If provided, the returned token will allow you to make API calls on behalf of this user.

        try {
            'String' result = apiInstance.v1getApiToken(xProxy);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#v1getApiToken");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic_auth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AuthApi *apiInstance = [[AuthApi alloc] init];
String *xProxy = xProxy_example; // The ID of a user you have proxy access to. If provided, the returned token will allow you to make API calls on behalf of this user. (optional) (default to null)

// Generate an API token
[apiInstance v1getApiTokenWith:xProxy
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.AuthApi()
var opts = {
  'xProxy': xProxy_example // {String} The ID of a user you have proxy access to. If provided, the returned token will allow you to make API calls on behalf of this user.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.v1getApiToken(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AuthApi();
            var xProxy = xProxy_example;  // String | The ID of a user you have proxy access to. If provided, the returned token will allow you to make API calls on behalf of this user. (optional)  (default to null)

            try {
                // Generate an API token
                'String' result = apiInstance.v1getApiToken(xProxy);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthApi.v1getApiToken: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basic_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthApi();
$xProxy = xProxy_example; // String | The ID of a user you have proxy access to. If provided, the returned token will allow you to make API calls on behalf of this user.

try {
    $result = $api_instance->v1getApiToken($xProxy);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->v1getApiToken: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AuthApi;
# Configure HTTP basic authorization: basic_auth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthApi->new();
my $xProxy = xProxy_example; # String | The ID of a user you have proxy access to. If provided, the returned token will allow you to make API calls on behalf of this user.

eval {
    my $result = $api_instance->v1getApiToken(xProxy => $xProxy);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthApi->v1getApiToken: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: basic_auth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AuthApi()
xProxy = xProxy_example # String | The ID of a user you have proxy access to. If provided, the returned token will allow you to make API calls on behalf of this user. (optional) (default to null)

try:
    # Generate an API token
    api_response = api_instance.v1get_api_token(xProxy=xProxy)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthApi->v1getApiToken: %s\n" % e)
extern crate AuthApi;

pub fn main() {
    let xProxy = xProxy_example; // String

    let mut context = AuthApi::Context::default();
    let result = client.v1getApiToken(xProxy, &context).wait();

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

Scopes

Parameters

Header parameters
Name Description
X-Proxy
String
The ID of a user you have proxy access to. If provided, the returned token will allow you to make API calls on behalf of this user.

Responses


GraphqlBatch

batches


/graphql?op=Batches

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/graphql?op=Batches" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GraphqlBatchApi;

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

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

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

        // Create an instance of the API class
        GraphqlBatchApi apiInstance = new GraphqlBatchApi();
        BatchesRequest batchesRequest = ; // BatchesRequest | 

        try {
            Batches_200_response result = apiInstance.batches(batchesRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphqlBatchApi#batches");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BatchesRequest batchesRequest = new BatchesRequest(); // BatchesRequest | 

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

import org.openapitools.client.api.GraphqlBatchApi;

public class GraphqlBatchApiExample {
    public static void main(String[] args) {
        GraphqlBatchApi apiInstance = new GraphqlBatchApi();
        BatchesRequest batchesRequest = ; // BatchesRequest | 

        try {
            Batches_200_response result = apiInstance.batches(batchesRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphqlBatchApi#batches");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
GraphqlBatchApi *apiInstance = [[GraphqlBatchApi alloc] init];
BatchesRequest *batchesRequest = ; //  (optional)

[apiInstance batchesWith:batchesRequest
              completionHandler: ^(Batches_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.GraphqlBatchApi()
var opts = {
  'batchesRequest':  // {BatchesRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.batches(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new GraphqlBatchApi();
            var batchesRequest = new BatchesRequest(); // BatchesRequest |  (optional) 

            try {
                Batches_200_response result = apiInstance.batches(batchesRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphqlBatchApi.batches: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphqlBatchApi();
$batchesRequest = ; // BatchesRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphqlBatchApi->new();
my $batchesRequest = WWW::OPenAPIClient::Object::BatchesRequest->new(); # BatchesRequest | 

eval {
    my $result = $api_instance->batches(batchesRequest => $batchesRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphqlBatchApi->batches: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.GraphqlBatchApi()
batchesRequest =  # BatchesRequest |  (optional)

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

pub fn main() {
    let batchesRequest = ; // BatchesRequest

    let mut context = GraphqlBatchApi::Context::default();
    let result = client.batches(batchesRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
batchesRequest

Responses


createBatch


/graphql?op=CreateBatch

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/graphql?op=CreateBatch" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GraphqlBatchApi;

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

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

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

        // Create an instance of the API class
        GraphqlBatchApi apiInstance = new GraphqlBatchApi();
        CreateBatchRequest createBatchRequest = ; // CreateBatchRequest | 

        try {
            CreateBatch_200_response result = apiInstance.createBatch(createBatchRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphqlBatchApi#createBatch");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreateBatchRequest createBatchRequest = new CreateBatchRequest(); // CreateBatchRequest | 

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

import org.openapitools.client.api.GraphqlBatchApi;

public class GraphqlBatchApiExample {
    public static void main(String[] args) {
        GraphqlBatchApi apiInstance = new GraphqlBatchApi();
        CreateBatchRequest createBatchRequest = ; // CreateBatchRequest | 

        try {
            CreateBatch_200_response result = apiInstance.createBatch(createBatchRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphqlBatchApi#createBatch");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
GraphqlBatchApi *apiInstance = [[GraphqlBatchApi alloc] init];
CreateBatchRequest *createBatchRequest = ; //  (optional)

[apiInstance createBatchWith:createBatchRequest
              completionHandler: ^(CreateBatch_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.GraphqlBatchApi()
var opts = {
  'createBatchRequest':  // {CreateBatchRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createBatch(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new GraphqlBatchApi();
            var createBatchRequest = new CreateBatchRequest(); // CreateBatchRequest |  (optional) 

            try {
                CreateBatch_200_response result = apiInstance.createBatch(createBatchRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphqlBatchApi.createBatch: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphqlBatchApi();
$createBatchRequest = ; // CreateBatchRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphqlBatchApi->new();
my $createBatchRequest = WWW::OPenAPIClient::Object::CreateBatchRequest->new(); # CreateBatchRequest | 

eval {
    my $result = $api_instance->createBatch(createBatchRequest => $createBatchRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphqlBatchApi->createBatch: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.GraphqlBatchApi()
createBatchRequest =  # CreateBatchRequest |  (optional)

try:
    api_response = api_instance.create_batch(createBatchRequest=createBatchRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphqlBatchApi->createBatch: %s\n" % e)
extern crate GraphqlBatchApi;

pub fn main() {
    let createBatchRequest = ; // CreateBatchRequest

    let mut context = GraphqlBatchApi::Context::default();
    let result = client.createBatch(createBatchRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
createBatchRequest

Responses


updateBatch


/graphql?op=UpdateBatch

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/graphql?op=UpdateBatch" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GraphqlBatchApi;

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

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

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

        // Create an instance of the API class
        GraphqlBatchApi apiInstance = new GraphqlBatchApi();
        UpdateBatchRequest updateBatchRequest = ; // UpdateBatchRequest | 

        try {
            UpdateBatch_200_response result = apiInstance.updateBatch(updateBatchRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphqlBatchApi#updateBatch");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UpdateBatchRequest updateBatchRequest = new UpdateBatchRequest(); // UpdateBatchRequest | 

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

import org.openapitools.client.api.GraphqlBatchApi;

public class GraphqlBatchApiExample {
    public static void main(String[] args) {
        GraphqlBatchApi apiInstance = new GraphqlBatchApi();
        UpdateBatchRequest updateBatchRequest = ; // UpdateBatchRequest | 

        try {
            UpdateBatch_200_response result = apiInstance.updateBatch(updateBatchRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphqlBatchApi#updateBatch");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
GraphqlBatchApi *apiInstance = [[GraphqlBatchApi alloc] init];
UpdateBatchRequest *updateBatchRequest = ; //  (optional)

[apiInstance updateBatchWith:updateBatchRequest
              completionHandler: ^(UpdateBatch_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.GraphqlBatchApi()
var opts = {
  'updateBatchRequest':  // {UpdateBatchRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateBatch(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new GraphqlBatchApi();
            var updateBatchRequest = new UpdateBatchRequest(); // UpdateBatchRequest |  (optional) 

            try {
                UpdateBatch_200_response result = apiInstance.updateBatch(updateBatchRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphqlBatchApi.updateBatch: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphqlBatchApi();
$updateBatchRequest = ; // UpdateBatchRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphqlBatchApi->new();
my $updateBatchRequest = WWW::OPenAPIClient::Object::UpdateBatchRequest->new(); # UpdateBatchRequest | 

eval {
    my $result = $api_instance->updateBatch(updateBatchRequest => $updateBatchRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphqlBatchApi->updateBatch: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.GraphqlBatchApi()
updateBatchRequest =  # UpdateBatchRequest |  (optional)

try:
    api_response = api_instance.update_batch(updateBatchRequest=updateBatchRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphqlBatchApi->updateBatch: %s\n" % e)
extern crate GraphqlBatchApi;

pub fn main() {
    let updateBatchRequest = ; // UpdateBatchRequest

    let mut context = GraphqlBatchApi::Context::default();
    let result = client.updateBatch(updateBatchRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
updateBatchRequest

Responses


GraphqlBuylist

buylist


/graphql?op=Buylist

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/graphql?op=Buylist" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GraphqlBuylistApi;

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

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

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

        // Create an instance of the API class
        GraphqlBuylistApi apiInstance = new GraphqlBuylistApi();
        BuylistRequest buylistRequest = ; // BuylistRequest | 

        try {
            Buylist_200_response result = apiInstance.buylist(buylistRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphqlBuylistApi#buylist");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BuylistRequest buylistRequest = new BuylistRequest(); // BuylistRequest | 

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

import org.openapitools.client.api.GraphqlBuylistApi;

public class GraphqlBuylistApiExample {
    public static void main(String[] args) {
        GraphqlBuylistApi apiInstance = new GraphqlBuylistApi();
        BuylistRequest buylistRequest = ; // BuylistRequest | 

        try {
            Buylist_200_response result = apiInstance.buylist(buylistRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphqlBuylistApi#buylist");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
GraphqlBuylistApi *apiInstance = [[GraphqlBuylistApi alloc] init];
BuylistRequest *buylistRequest = ; //  (optional)

[apiInstance buylistWith:buylistRequest
              completionHandler: ^(Buylist_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.GraphqlBuylistApi()
var opts = {
  'buylistRequest':  // {BuylistRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.buylist(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new GraphqlBuylistApi();
            var buylistRequest = new BuylistRequest(); // BuylistRequest |  (optional) 

            try {
                Buylist_200_response result = apiInstance.buylist(buylistRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphqlBuylistApi.buylist: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphqlBuylistApi();
$buylistRequest = ; // BuylistRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphqlBuylistApi->new();
my $buylistRequest = WWW::OPenAPIClient::Object::BuylistRequest->new(); # BuylistRequest | 

eval {
    my $result = $api_instance->buylist(buylistRequest => $buylistRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphqlBuylistApi->buylist: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.GraphqlBuylistApi()
buylistRequest =  # BuylistRequest |  (optional)

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

pub fn main() {
    let buylistRequest = ; // BuylistRequest

    let mut context = GraphqlBuylistApi::Context::default();
    let result = client.buylist(buylistRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
buylistRequest

Responses


GraphqlInventory

inventory


/graphql?op=Inventory

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/graphql?op=Inventory" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GraphqlInventoryApi;

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

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

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

        // Create an instance of the API class
        GraphqlInventoryApi apiInstance = new GraphqlInventoryApi();
        InventoryRequest inventoryRequest = ; // InventoryRequest | 

        try {
            Inventory_200_response result = apiInstance.inventory(inventoryRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphqlInventoryApi#inventory");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final InventoryRequest inventoryRequest = new InventoryRequest(); // InventoryRequest | 

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

import org.openapitools.client.api.GraphqlInventoryApi;

public class GraphqlInventoryApiExample {
    public static void main(String[] args) {
        GraphqlInventoryApi apiInstance = new GraphqlInventoryApi();
        InventoryRequest inventoryRequest = ; // InventoryRequest | 

        try {
            Inventory_200_response result = apiInstance.inventory(inventoryRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphqlInventoryApi#inventory");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
GraphqlInventoryApi *apiInstance = [[GraphqlInventoryApi alloc] init];
InventoryRequest *inventoryRequest = ; //  (optional)

[apiInstance inventoryWith:inventoryRequest
              completionHandler: ^(Inventory_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.GraphqlInventoryApi()
var opts = {
  'inventoryRequest':  // {InventoryRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.inventory(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new GraphqlInventoryApi();
            var inventoryRequest = new InventoryRequest(); // InventoryRequest |  (optional) 

            try {
                Inventory_200_response result = apiInstance.inventory(inventoryRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphqlInventoryApi.inventory: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphqlInventoryApi();
$inventoryRequest = ; // InventoryRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphqlInventoryApi->new();
my $inventoryRequest = WWW::OPenAPIClient::Object::InventoryRequest->new(); # InventoryRequest | 

eval {
    my $result = $api_instance->inventory(inventoryRequest => $inventoryRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphqlInventoryApi->inventory: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.GraphqlInventoryApi()
inventoryRequest =  # InventoryRequest |  (optional)

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

pub fn main() {
    let inventoryRequest = ; // InventoryRequest

    let mut context = GraphqlInventoryApi::Context::default();
    let result = client.inventory(inventoryRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
inventoryRequest

Responses


updateInventoryItems


/graphql?op=UpdateInventoryItems

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/graphql?op=UpdateInventoryItems" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GraphqlInventoryApi;

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

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

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

        // Create an instance of the API class
        GraphqlInventoryApi apiInstance = new GraphqlInventoryApi();
        UpdateInventoryItemsRequest updateInventoryItemsRequest = ; // UpdateInventoryItemsRequest | 

        try {
            UpdateInventoryItems_200_response result = apiInstance.updateInventoryItems(updateInventoryItemsRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphqlInventoryApi#updateInventoryItems");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UpdateInventoryItemsRequest updateInventoryItemsRequest = new UpdateInventoryItemsRequest(); // UpdateInventoryItemsRequest | 

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

import org.openapitools.client.api.GraphqlInventoryApi;

public class GraphqlInventoryApiExample {
    public static void main(String[] args) {
        GraphqlInventoryApi apiInstance = new GraphqlInventoryApi();
        UpdateInventoryItemsRequest updateInventoryItemsRequest = ; // UpdateInventoryItemsRequest | 

        try {
            UpdateInventoryItems_200_response result = apiInstance.updateInventoryItems(updateInventoryItemsRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphqlInventoryApi#updateInventoryItems");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
GraphqlInventoryApi *apiInstance = [[GraphqlInventoryApi alloc] init];
UpdateInventoryItemsRequest *updateInventoryItemsRequest = ; //  (optional)

[apiInstance updateInventoryItemsWith:updateInventoryItemsRequest
              completionHandler: ^(UpdateInventoryItems_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.GraphqlInventoryApi()
var opts = {
  'updateInventoryItemsRequest':  // {UpdateInventoryItemsRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateInventoryItems(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new GraphqlInventoryApi();
            var updateInventoryItemsRequest = new UpdateInventoryItemsRequest(); // UpdateInventoryItemsRequest |  (optional) 

            try {
                UpdateInventoryItems_200_response result = apiInstance.updateInventoryItems(updateInventoryItemsRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphqlInventoryApi.updateInventoryItems: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphqlInventoryApi();
$updateInventoryItemsRequest = ; // UpdateInventoryItemsRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphqlInventoryApi->new();
my $updateInventoryItemsRequest = WWW::OPenAPIClient::Object::UpdateInventoryItemsRequest->new(); # UpdateInventoryItemsRequest | 

eval {
    my $result = $api_instance->updateInventoryItems(updateInventoryItemsRequest => $updateInventoryItemsRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphqlInventoryApi->updateInventoryItems: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.GraphqlInventoryApi()
updateInventoryItemsRequest =  # UpdateInventoryItemsRequest |  (optional)

try:
    api_response = api_instance.update_inventory_items(updateInventoryItemsRequest=updateInventoryItemsRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphqlInventoryApi->updateInventoryItems: %s\n" % e)
extern crate GraphqlInventoryApi;

pub fn main() {
    let updateInventoryItemsRequest = ; // UpdateInventoryItemsRequest

    let mut context = GraphqlInventoryApi::Context::default();
    let result = client.updateInventoryItems(updateInventoryItemsRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
updateInventoryItemsRequest

Responses


GraphqlSearchhistory

searchHistory


/graphql?op=SearchHistory

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/graphql?op=SearchHistory" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GraphqlSearchhistoryApi;

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

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

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

        // Create an instance of the API class
        GraphqlSearchhistoryApi apiInstance = new GraphqlSearchhistoryApi();
        SearchHistoryRequest searchHistoryRequest = ; // SearchHistoryRequest | 

        try {
            SearchHistory_200_response result = apiInstance.searchHistory(searchHistoryRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphqlSearchhistoryApi#searchHistory");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final SearchHistoryRequest searchHistoryRequest = new SearchHistoryRequest(); // SearchHistoryRequest | 

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

import org.openapitools.client.api.GraphqlSearchhistoryApi;

public class GraphqlSearchhistoryApiExample {
    public static void main(String[] args) {
        GraphqlSearchhistoryApi apiInstance = new GraphqlSearchhistoryApi();
        SearchHistoryRequest searchHistoryRequest = ; // SearchHistoryRequest | 

        try {
            SearchHistory_200_response result = apiInstance.searchHistory(searchHistoryRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphqlSearchhistoryApi#searchHistory");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
GraphqlSearchhistoryApi *apiInstance = [[GraphqlSearchhistoryApi alloc] init];
SearchHistoryRequest *searchHistoryRequest = ; //  (optional)

[apiInstance searchHistoryWith:searchHistoryRequest
              completionHandler: ^(SearchHistory_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.GraphqlSearchhistoryApi()
var opts = {
  'searchHistoryRequest':  // {SearchHistoryRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.searchHistory(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new GraphqlSearchhistoryApi();
            var searchHistoryRequest = new SearchHistoryRequest(); // SearchHistoryRequest |  (optional) 

            try {
                SearchHistory_200_response result = apiInstance.searchHistory(searchHistoryRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphqlSearchhistoryApi.searchHistory: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphqlSearchhistoryApi();
$searchHistoryRequest = ; // SearchHistoryRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphqlSearchhistoryApi->new();
my $searchHistoryRequest = WWW::OPenAPIClient::Object::SearchHistoryRequest->new(); # SearchHistoryRequest | 

eval {
    my $result = $api_instance->searchHistory(searchHistoryRequest => $searchHistoryRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphqlSearchhistoryApi->searchHistory: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.GraphqlSearchhistoryApi()
searchHistoryRequest =  # SearchHistoryRequest |  (optional)

try:
    api_response = api_instance.search_history(searchHistoryRequest=searchHistoryRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphqlSearchhistoryApi->searchHistory: %s\n" % e)
extern crate GraphqlSearchhistoryApi;

pub fn main() {
    let searchHistoryRequest = ; // SearchHistoryRequest

    let mut context = GraphqlSearchhistoryApi::Context::default();
    let result = client.searchHistory(searchHistoryRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
searchHistoryRequest

Responses


SpApiCatalogItems

searchCatalogItems

A wrapper around Amazon's [searchCatalogItems](https://developer-docs.amazon.com/sp-api/docs/catalog-items-api-v2022-04-01-reference#searchcatalogitems) API


/api/az/catalog/items

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/catalog/items?identifiers=B001FOQJOG&identifiersType=ASIN&marketplaceIds=US&includedData=includedData_example&locale=locale_example&keywords=keywords_example&brandNames=brandNames_example&classificationIds=classificationIds_example&pageSize=10&pageToken=pageToken_example&keywordsLocale=keywordsLocale_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiCatalogItemsApi;

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

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

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

        // Create an instance of the API class
        SpApiCatalogItemsApi apiInstance = new SpApiCatalogItemsApi();
        String identifiers = B001FOQJOG; // String | A comma separated list of identifiers. Note that SKUs with commas need to be searched one at a time.
        String identifiersType = ASIN; // String | [IdentifiersType](https://developer-docs.amazon.com/sp-api/docs/catalog-items-api-v2022-04-01-reference#identifierstype)
        array[String] marketplaceIds = US; // array[String] | 
        String includedData = includedData_example; // String | A comma separated list of one or more [IncludedData](https://developer-docs.amazon.com/sp-api/docs/catalog-items-api-v2022-04-01-reference#includeddata-subgroup-2), defaults to `summaries`.
        String locale = locale_example; // String | 
        String keywords = keywords_example; // String | 
        String brandNames = brandNames_example; // String | 
        String classificationIds = classificationIds_example; // String | 
        Integer pageSize = 10; // Integer | 
        String pageToken = pageToken_example; // String | 
        String keywordsLocale = keywordsLocale_example; // String | 

        try {
            Object result = apiInstance.searchCatalogItems(identifiers, identifiersType, marketplaceIds, includedData, locale, keywords, brandNames, classificationIds, pageSize, pageToken, keywordsLocale);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiCatalogItemsApi#searchCatalogItems");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String identifiers = new String(); // String | A comma separated list of identifiers. Note that SKUs with commas need to be searched one at a time.
final String identifiersType = new String(); // String | [IdentifiersType](https://developer-docs.amazon.com/sp-api/docs/catalog-items-api-v2022-04-01-reference#identifierstype)
final array[String] marketplaceIds = new array[String](); // array[String] | 
final String includedData = new String(); // String | A comma separated list of one or more [IncludedData](https://developer-docs.amazon.com/sp-api/docs/catalog-items-api-v2022-04-01-reference#includeddata-subgroup-2), defaults to `summaries`.
final String locale = new String(); // String | 
final String keywords = new String(); // String | 
final String brandNames = new String(); // String | 
final String classificationIds = new String(); // String | 
final Integer pageSize = new Integer(); // Integer | 
final String pageToken = new String(); // String | 
final String keywordsLocale = new String(); // String | 

try {
    final result = await api_instance.searchCatalogItems(identifiers, identifiersType, marketplaceIds, includedData, locale, keywords, brandNames, classificationIds, pageSize, pageToken, keywordsLocale);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->searchCatalogItems: $e\n');
}

import org.openapitools.client.api.SpApiCatalogItemsApi;

public class SpApiCatalogItemsApiExample {
    public static void main(String[] args) {
        SpApiCatalogItemsApi apiInstance = new SpApiCatalogItemsApi();
        String identifiers = B001FOQJOG; // String | A comma separated list of identifiers. Note that SKUs with commas need to be searched one at a time.
        String identifiersType = ASIN; // String | [IdentifiersType](https://developer-docs.amazon.com/sp-api/docs/catalog-items-api-v2022-04-01-reference#identifierstype)
        array[String] marketplaceIds = US; // array[String] | 
        String includedData = includedData_example; // String | A comma separated list of one or more [IncludedData](https://developer-docs.amazon.com/sp-api/docs/catalog-items-api-v2022-04-01-reference#includeddata-subgroup-2), defaults to `summaries`.
        String locale = locale_example; // String | 
        String keywords = keywords_example; // String | 
        String brandNames = brandNames_example; // String | 
        String classificationIds = classificationIds_example; // String | 
        Integer pageSize = 10; // Integer | 
        String pageToken = pageToken_example; // String | 
        String keywordsLocale = keywordsLocale_example; // String | 

        try {
            Object result = apiInstance.searchCatalogItems(identifiers, identifiersType, marketplaceIds, includedData, locale, keywords, brandNames, classificationIds, pageSize, pageToken, keywordsLocale);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiCatalogItemsApi#searchCatalogItems");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiCatalogItemsApi *apiInstance = [[SpApiCatalogItemsApi alloc] init];
String *identifiers = B001FOQJOG; // A comma separated list of identifiers. Note that SKUs with commas need to be searched one at a time. (optional) (default to null)
String *identifiersType = ASIN; // [IdentifiersType](https://developer-docs.amazon.com/sp-api/docs/catalog-items-api-v2022-04-01-reference#identifierstype) (optional) (default to null)
array[String] *marketplaceIds = US; //  (optional) (default to null)
String *includedData = includedData_example; // A comma separated list of one or more [IncludedData](https://developer-docs.amazon.com/sp-api/docs/catalog-items-api-v2022-04-01-reference#includeddata-subgroup-2), defaults to `summaries`. (optional) (default to null)
String *locale = locale_example; //  (optional) (default to null)
String *keywords = keywords_example; //  (optional) (default to null)
String *brandNames = brandNames_example; //  (optional) (default to null)
String *classificationIds = classificationIds_example; //  (optional) (default to null)
Integer *pageSize = 10; //  (optional) (default to null)
String *pageToken = pageToken_example; //  (optional) (default to null)
String *keywordsLocale = keywordsLocale_example; //  (optional) (default to null)

[apiInstance searchCatalogItemsWith:identifiers
    identifiersType:identifiersType
    marketplaceIds:marketplaceIds
    includedData:includedData
    locale:locale
    keywords:keywords
    brandNames:brandNames
    classificationIds:classificationIds
    pageSize:pageSize
    pageToken:pageToken
    keywordsLocale:keywordsLocale
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiCatalogItemsApi()
var opts = {
  'identifiers': B001FOQJOG, // {String} A comma separated list of identifiers. Note that SKUs with commas need to be searched one at a time.
  'identifiersType': ASIN, // {String} [IdentifiersType](https://developer-docs.amazon.com/sp-api/docs/catalog-items-api-v2022-04-01-reference#identifierstype)
  'marketplaceIds': US, // {array[String]} 
  'includedData': includedData_example, // {String} A comma separated list of one or more [IncludedData](https://developer-docs.amazon.com/sp-api/docs/catalog-items-api-v2022-04-01-reference#includeddata-subgroup-2), defaults to `summaries`.
  'locale': locale_example, // {String} 
  'keywords': keywords_example, // {String} 
  'brandNames': brandNames_example, // {String} 
  'classificationIds': classificationIds_example, // {String} 
  'pageSize': 10, // {Integer} 
  'pageToken': pageToken_example, // {String} 
  'keywordsLocale': keywordsLocale_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.searchCatalogItems(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiCatalogItemsApi();
            var identifiers = B001FOQJOG;  // String | A comma separated list of identifiers. Note that SKUs with commas need to be searched one at a time. (optional)  (default to null)
            var identifiersType = ASIN;  // String | [IdentifiersType](https://developer-docs.amazon.com/sp-api/docs/catalog-items-api-v2022-04-01-reference#identifierstype) (optional)  (default to null)
            var marketplaceIds = new array[String](); // array[String] |  (optional)  (default to null)
            var includedData = includedData_example;  // String | A comma separated list of one or more [IncludedData](https://developer-docs.amazon.com/sp-api/docs/catalog-items-api-v2022-04-01-reference#includeddata-subgroup-2), defaults to `summaries`. (optional)  (default to null)
            var locale = locale_example;  // String |  (optional)  (default to null)
            var keywords = keywords_example;  // String |  (optional)  (default to null)
            var brandNames = brandNames_example;  // String |  (optional)  (default to null)
            var classificationIds = classificationIds_example;  // String |  (optional)  (default to null)
            var pageSize = 10;  // Integer |  (optional)  (default to null)
            var pageToken = pageToken_example;  // String |  (optional)  (default to null)
            var keywordsLocale = keywordsLocale_example;  // String |  (optional)  (default to null)

            try {
                Object result = apiInstance.searchCatalogItems(identifiers, identifiersType, marketplaceIds, includedData, locale, keywords, brandNames, classificationIds, pageSize, pageToken, keywordsLocale);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiCatalogItemsApi.searchCatalogItems: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiCatalogItemsApi();
$identifiers = B001FOQJOG; // String | A comma separated list of identifiers. Note that SKUs with commas need to be searched one at a time.
$identifiersType = ASIN; // String | [IdentifiersType](https://developer-docs.amazon.com/sp-api/docs/catalog-items-api-v2022-04-01-reference#identifierstype)
$marketplaceIds = US; // array[String] | 
$includedData = includedData_example; // String | A comma separated list of one or more [IncludedData](https://developer-docs.amazon.com/sp-api/docs/catalog-items-api-v2022-04-01-reference#includeddata-subgroup-2), defaults to `summaries`.
$locale = locale_example; // String | 
$keywords = keywords_example; // String | 
$brandNames = brandNames_example; // String | 
$classificationIds = classificationIds_example; // String | 
$pageSize = 10; // Integer | 
$pageToken = pageToken_example; // String | 
$keywordsLocale = keywordsLocale_example; // String | 

try {
    $result = $api_instance->searchCatalogItems($identifiers, $identifiersType, $marketplaceIds, $includedData, $locale, $keywords, $brandNames, $classificationIds, $pageSize, $pageToken, $keywordsLocale);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SpApiCatalogItemsApi->searchCatalogItems: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SpApiCatalogItemsApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiCatalogItemsApi->new();
my $identifiers = B001FOQJOG; # String | A comma separated list of identifiers. Note that SKUs with commas need to be searched one at a time.
my $identifiersType = ASIN; # String | [IdentifiersType](https://developer-docs.amazon.com/sp-api/docs/catalog-items-api-v2022-04-01-reference#identifierstype)
my $marketplaceIds = [US]; # array[String] | 
my $includedData = includedData_example; # String | A comma separated list of one or more [IncludedData](https://developer-docs.amazon.com/sp-api/docs/catalog-items-api-v2022-04-01-reference#includeddata-subgroup-2), defaults to `summaries`.
my $locale = locale_example; # String | 
my $keywords = keywords_example; # String | 
my $brandNames = brandNames_example; # String | 
my $classificationIds = classificationIds_example; # String | 
my $pageSize = 10; # Integer | 
my $pageToken = pageToken_example; # String | 
my $keywordsLocale = keywordsLocale_example; # String | 

eval {
    my $result = $api_instance->searchCatalogItems(identifiers => $identifiers, identifiersType => $identifiersType, marketplaceIds => $marketplaceIds, includedData => $includedData, locale => $locale, keywords => $keywords, brandNames => $brandNames, classificationIds => $classificationIds, pageSize => $pageSize, pageToken => $pageToken, keywordsLocale => $keywordsLocale);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiCatalogItemsApi->searchCatalogItems: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiCatalogItemsApi()
identifiers = B001FOQJOG # String | A comma separated list of identifiers. Note that SKUs with commas need to be searched one at a time. (optional) (default to null)
identifiersType = ASIN # String | [IdentifiersType](https://developer-docs.amazon.com/sp-api/docs/catalog-items-api-v2022-04-01-reference#identifierstype) (optional) (default to null)
marketplaceIds = US # array[String] |  (optional) (default to null)
includedData = includedData_example # String | A comma separated list of one or more [IncludedData](https://developer-docs.amazon.com/sp-api/docs/catalog-items-api-v2022-04-01-reference#includeddata-subgroup-2), defaults to `summaries`. (optional) (default to null)
locale = locale_example # String |  (optional) (default to null)
keywords = keywords_example # String |  (optional) (default to null)
brandNames = brandNames_example # String |  (optional) (default to null)
classificationIds = classificationIds_example # String |  (optional) (default to null)
pageSize = 10 # Integer |  (optional) (default to null)
pageToken = pageToken_example # String |  (optional) (default to null)
keywordsLocale = keywordsLocale_example # String |  (optional) (default to null)

try:
    api_response = api_instance.search_catalog_items(identifiers=identifiers, identifiersType=identifiersType, marketplaceIds=marketplaceIds, includedData=includedData, locale=locale, keywords=keywords, brandNames=brandNames, classificationIds=classificationIds, pageSize=pageSize, pageToken=pageToken, keywordsLocale=keywordsLocale)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiCatalogItemsApi->searchCatalogItems: %s\n" % e)
extern crate SpApiCatalogItemsApi;

pub fn main() {
    let identifiers = B001FOQJOG; // String
    let identifiersType = ASIN; // String
    let marketplaceIds = US; // array[String]
    let includedData = includedData_example; // String
    let locale = locale_example; // String
    let keywords = keywords_example; // String
    let brandNames = brandNames_example; // String
    let classificationIds = classificationIds_example; // String
    let pageSize = 10; // Integer
    let pageToken = pageToken_example; // String
    let keywordsLocale = keywordsLocale_example; // String

    let mut context = SpApiCatalogItemsApi::Context::default();
    let result = client.searchCatalogItems(identifiers, identifiersType, marketplaceIds, includedData, locale, keywords, brandNames, classificationIds, pageSize, pageToken, keywordsLocale, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
identifiers
String
A comma separated list of identifiers. Note that SKUs with commas need to be searched one at a time.
identifiersType
String
[IdentifiersType](https://developer-docs.amazon.com/sp-api/docs/catalog-items-api-v2022-04-01-reference#identifierstype)
marketplaceIds
array[String]
includedData
String
A comma separated list of one or more [IncludedData](https://developer-docs.amazon.com/sp-api/docs/catalog-items-api-v2022-04-01-reference#includeddata-subgroup-2), defaults to `summaries`.
locale
String
keywords
String
brandNames
String
classificationIds
String
pageSize
Integer
pageToken
String
keywordsLocale
String

Responses


SpApiFbaInbound

cancelInboundPlan

A wrapper around Amazon's [cancelInboundPlan](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#cancelinboundplan) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/cancellation

Usage and SDK Samples

curl -X PUT \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/cancellation?operationComplete=1"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

        try {
            cancelInboundPlan_200_response result = apiInstance.cancelInboundPlan(inboundPlanId, operationComplete);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#cancelInboundPlan");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final Integer operationComplete = new Integer(); // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

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

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

        try {
            cancelInboundPlan_200_response result = apiInstance.cancelInboundPlan(inboundPlanId, operationComplete);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#cancelInboundPlan");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
Integer *operationComplete = 1; // Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)

[apiInstance cancelInboundPlanWith:inboundPlanId
    operationComplete:operationComplete
              completionHandler: ^(cancelInboundPlan_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var opts = {
  'operationComplete': 1 // {Integer} Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.cancelInboundPlan(inboundPlanId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var operationComplete = 1;  // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional)  (default to null)

            try {
                cancelInboundPlan_200_response result = apiInstance.cancelInboundPlan(inboundPlanId, operationComplete);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.cancelInboundPlan: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $operationComplete = 1; # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

eval {
    my $result = $api_instance->cancelInboundPlan(inboundPlanId => $inboundPlanId, operationComplete => $operationComplete);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->cancelInboundPlan: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
operationComplete = 1 # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)

try:
    api_response = api_instance.cancel_inbound_plan(inboundPlanId, operationComplete=operationComplete)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->cancelInboundPlan: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let operationComplete = 1; // Integer

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.cancelInboundPlan(inboundPlanId, operationComplete, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
Query parameters
Name Description
operationComplete
Integer
Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

Responses

Name Type Format Description
x-request-id String

cancelSelfShipAppointment

A wrapper around Amazon's [cancelSelfShipAppointment](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#cancelselfshipappointment) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/selfShipAppointmentCancellation

Usage and SDK Samples

curl -X PUT \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/selfShipAppointmentCancellation?operationComplete=1" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
        CancelSelfShipAppointmentRequest cancelSelfShipAppointmentRequest = ; // CancelSelfShipAppointmentRequest | 

        try {
            cancelSelfShipAppointment_200_response result = apiInstance.cancelSelfShipAppointment(inboundPlanId, shipmentId, operationComplete, cancelSelfShipAppointmentRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#cancelSelfShipAppointment");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String shipmentId = new String(); // String | 
final Integer operationComplete = new Integer(); // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
final CancelSelfShipAppointmentRequest cancelSelfShipAppointmentRequest = new CancelSelfShipAppointmentRequest(); // CancelSelfShipAppointmentRequest | 

try {
    final result = await api_instance.cancelSelfShipAppointment(inboundPlanId, shipmentId, operationComplete, cancelSelfShipAppointmentRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->cancelSelfShipAppointment: $e\n');
}

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
        CancelSelfShipAppointmentRequest cancelSelfShipAppointmentRequest = ; // CancelSelfShipAppointmentRequest | 

        try {
            cancelSelfShipAppointment_200_response result = apiInstance.cancelSelfShipAppointment(inboundPlanId, shipmentId, operationComplete, cancelSelfShipAppointmentRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#cancelSelfShipAppointment");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *shipmentId = shipmentId_example; //  (default to null)
Integer *operationComplete = 1; // Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)
CancelSelfShipAppointmentRequest *cancelSelfShipAppointmentRequest = ; //  (optional)

[apiInstance cancelSelfShipAppointmentWith:inboundPlanId
    shipmentId:shipmentId
    operationComplete:operationComplete
    cancelSelfShipAppointmentRequest:cancelSelfShipAppointmentRequest
              completionHandler: ^(cancelSelfShipAppointment_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var shipmentId = shipmentId_example; // {String} 
var opts = {
  'operationComplete': 1, // {Integer} Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
  'cancelSelfShipAppointmentRequest':  // {CancelSelfShipAppointmentRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.cancelSelfShipAppointment(inboundPlanId, shipmentId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var shipmentId = shipmentId_example;  // String |  (default to null)
            var operationComplete = 1;  // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional)  (default to null)
            var cancelSelfShipAppointmentRequest = new CancelSelfShipAppointmentRequest(); // CancelSelfShipAppointmentRequest |  (optional) 

            try {
                cancelSelfShipAppointment_200_response result = apiInstance.cancelSelfShipAppointment(inboundPlanId, shipmentId, operationComplete, cancelSelfShipAppointmentRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.cancelSelfShipAppointment: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$shipmentId = shipmentId_example; // String | 
$operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
$cancelSelfShipAppointmentRequest = ; // CancelSelfShipAppointmentRequest | 

try {
    $result = $api_instance->cancelSelfShipAppointment($inboundPlanId, $shipmentId, $operationComplete, $cancelSelfShipAppointmentRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SpApiFbaInboundApi->cancelSelfShipAppointment: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SpApiFbaInboundApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $shipmentId = shipmentId_example; # String | 
my $operationComplete = 1; # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
my $cancelSelfShipAppointmentRequest = WWW::OPenAPIClient::Object::CancelSelfShipAppointmentRequest->new(); # CancelSelfShipAppointmentRequest | 

eval {
    my $result = $api_instance->cancelSelfShipAppointment(inboundPlanId => $inboundPlanId, shipmentId => $shipmentId, operationComplete => $operationComplete, cancelSelfShipAppointmentRequest => $cancelSelfShipAppointmentRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->cancelSelfShipAppointment: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
shipmentId = shipmentId_example # String |  (default to null)
operationComplete = 1 # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)
cancelSelfShipAppointmentRequest =  # CancelSelfShipAppointmentRequest |  (optional)

try:
    api_response = api_instance.cancel_self_ship_appointment(inboundPlanId, shipmentId, operationComplete=operationComplete, cancelSelfShipAppointmentRequest=cancelSelfShipAppointmentRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->cancelSelfShipAppointment: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let shipmentId = shipmentId_example; // String
    let operationComplete = 1; // Integer
    let cancelSelfShipAppointmentRequest = ; // CancelSelfShipAppointmentRequest

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.cancelSelfShipAppointment(inboundPlanId, shipmentId, operationComplete, cancelSelfShipAppointmentRequest, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
shipmentId*
String
Required
Body parameters
Name Description
cancelSelfShipAppointmentRequest

Query parameters
Name Description
operationComplete
Integer
Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

Responses

Name Type Format Description
x-request-id String

confirmDeliveryWindowOptions

A wrapper around Amazon's [confirmDeliveryWindowOptions](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#confirmdeliverywindowoptions) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/deliveryWindowOptions/{deliveryWindowOptionId}/confirmation

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/deliveryWindowOptions/{deliveryWindowOptionId}/confirmation?operationComplete=1"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        String deliveryWindowOptionId = deliveryWindowOptionId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

        try {
            confirmDeliveryWindowOptions_200_response result = apiInstance.confirmDeliveryWindowOptions(inboundPlanId, shipmentId, deliveryWindowOptionId, operationComplete);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#confirmDeliveryWindowOptions");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String shipmentId = new String(); // String | 
final String deliveryWindowOptionId = new String(); // String | 
final Integer operationComplete = new Integer(); // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

try {
    final result = await api_instance.confirmDeliveryWindowOptions(inboundPlanId, shipmentId, deliveryWindowOptionId, operationComplete);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->confirmDeliveryWindowOptions: $e\n');
}

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        String deliveryWindowOptionId = deliveryWindowOptionId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

        try {
            confirmDeliveryWindowOptions_200_response result = apiInstance.confirmDeliveryWindowOptions(inboundPlanId, shipmentId, deliveryWindowOptionId, operationComplete);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#confirmDeliveryWindowOptions");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *shipmentId = shipmentId_example; //  (default to null)
String *deliveryWindowOptionId = deliveryWindowOptionId_example; //  (default to null)
Integer *operationComplete = 1; // Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)

[apiInstance confirmDeliveryWindowOptionsWith:inboundPlanId
    shipmentId:shipmentId
    deliveryWindowOptionId:deliveryWindowOptionId
    operationComplete:operationComplete
              completionHandler: ^(confirmDeliveryWindowOptions_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var shipmentId = shipmentId_example; // {String} 
var deliveryWindowOptionId = deliveryWindowOptionId_example; // {String} 
var opts = {
  'operationComplete': 1 // {Integer} Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.confirmDeliveryWindowOptions(inboundPlanId, shipmentId, deliveryWindowOptionId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var shipmentId = shipmentId_example;  // String |  (default to null)
            var deliveryWindowOptionId = deliveryWindowOptionId_example;  // String |  (default to null)
            var operationComplete = 1;  // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional)  (default to null)

            try {
                confirmDeliveryWindowOptions_200_response result = apiInstance.confirmDeliveryWindowOptions(inboundPlanId, shipmentId, deliveryWindowOptionId, operationComplete);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.confirmDeliveryWindowOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$shipmentId = shipmentId_example; // String | 
$deliveryWindowOptionId = deliveryWindowOptionId_example; // String | 
$operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

try {
    $result = $api_instance->confirmDeliveryWindowOptions($inboundPlanId, $shipmentId, $deliveryWindowOptionId, $operationComplete);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SpApiFbaInboundApi->confirmDeliveryWindowOptions: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SpApiFbaInboundApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $shipmentId = shipmentId_example; # String | 
my $deliveryWindowOptionId = deliveryWindowOptionId_example; # String | 
my $operationComplete = 1; # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

eval {
    my $result = $api_instance->confirmDeliveryWindowOptions(inboundPlanId => $inboundPlanId, shipmentId => $shipmentId, deliveryWindowOptionId => $deliveryWindowOptionId, operationComplete => $operationComplete);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->confirmDeliveryWindowOptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
shipmentId = shipmentId_example # String |  (default to null)
deliveryWindowOptionId = deliveryWindowOptionId_example # String |  (default to null)
operationComplete = 1 # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)

try:
    api_response = api_instance.confirm_delivery_window_options(inboundPlanId, shipmentId, deliveryWindowOptionId, operationComplete=operationComplete)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->confirmDeliveryWindowOptions: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let shipmentId = shipmentId_example; // String
    let deliveryWindowOptionId = deliveryWindowOptionId_example; // String
    let operationComplete = 1; // Integer

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.confirmDeliveryWindowOptions(inboundPlanId, shipmentId, deliveryWindowOptionId, operationComplete, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
shipmentId*
String
Required
deliveryWindowOptionId*
String
Required
Query parameters
Name Description
operationComplete
Integer
Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

Responses

Name Type Format Description
x-request-id String

confirmPackingOption

A wrapper around Amazon's [confirmPackingOption](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#confirmpackingoption) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/packingOptions/{packingOptionId}/confirmation

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/packingOptions/{packingOptionId}/confirmation?operationComplete=1"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String packingOptionId = packingOptionId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

        try {
            confirmPackingOption_200_response result = apiInstance.confirmPackingOption(inboundPlanId, packingOptionId, operationComplete);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#confirmPackingOption");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String packingOptionId = new String(); // String | 
final Integer operationComplete = new Integer(); // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

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

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String packingOptionId = packingOptionId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

        try {
            confirmPackingOption_200_response result = apiInstance.confirmPackingOption(inboundPlanId, packingOptionId, operationComplete);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#confirmPackingOption");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *packingOptionId = packingOptionId_example; //  (default to null)
Integer *operationComplete = 1; // Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)

[apiInstance confirmPackingOptionWith:inboundPlanId
    packingOptionId:packingOptionId
    operationComplete:operationComplete
              completionHandler: ^(confirmPackingOption_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var packingOptionId = packingOptionId_example; // {String} 
var opts = {
  'operationComplete': 1 // {Integer} Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.confirmPackingOption(inboundPlanId, packingOptionId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var packingOptionId = packingOptionId_example;  // String |  (default to null)
            var operationComplete = 1;  // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional)  (default to null)

            try {
                confirmPackingOption_200_response result = apiInstance.confirmPackingOption(inboundPlanId, packingOptionId, operationComplete);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.confirmPackingOption: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$packingOptionId = packingOptionId_example; // String | 
$operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $packingOptionId = packingOptionId_example; # String | 
my $operationComplete = 1; # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

eval {
    my $result = $api_instance->confirmPackingOption(inboundPlanId => $inboundPlanId, packingOptionId => $packingOptionId, operationComplete => $operationComplete);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->confirmPackingOption: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
packingOptionId = packingOptionId_example # String |  (default to null)
operationComplete = 1 # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)

try:
    api_response = api_instance.confirm_packing_option(inboundPlanId, packingOptionId, operationComplete=operationComplete)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->confirmPackingOption: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let packingOptionId = packingOptionId_example; // String
    let operationComplete = 1; // Integer

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.confirmPackingOption(inboundPlanId, packingOptionId, operationComplete, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
packingOptionId*
String
Required
Query parameters
Name Description
operationComplete
Integer
Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

Responses

Name Type Format Description
x-request-id String

confirmPlacementOption

A wrapper around Amazon's [confirmPlacementOption](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#confirmplacementoption) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/placementOptions/{placementOptionId}/confirmation

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/placementOptions/{placementOptionId}/confirmation?operationComplete=1"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String placementOptionId = placementOptionId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

        try {
            confirmPlacementOption_200_response result = apiInstance.confirmPlacementOption(inboundPlanId, placementOptionId, operationComplete);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#confirmPlacementOption");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String placementOptionId = new String(); // String | 
final Integer operationComplete = new Integer(); // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

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

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String placementOptionId = placementOptionId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

        try {
            confirmPlacementOption_200_response result = apiInstance.confirmPlacementOption(inboundPlanId, placementOptionId, operationComplete);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#confirmPlacementOption");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *placementOptionId = placementOptionId_example; //  (default to null)
Integer *operationComplete = 1; // Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)

[apiInstance confirmPlacementOptionWith:inboundPlanId
    placementOptionId:placementOptionId
    operationComplete:operationComplete
              completionHandler: ^(confirmPlacementOption_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var placementOptionId = placementOptionId_example; // {String} 
var opts = {
  'operationComplete': 1 // {Integer} Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.confirmPlacementOption(inboundPlanId, placementOptionId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var placementOptionId = placementOptionId_example;  // String |  (default to null)
            var operationComplete = 1;  // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional)  (default to null)

            try {
                confirmPlacementOption_200_response result = apiInstance.confirmPlacementOption(inboundPlanId, placementOptionId, operationComplete);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.confirmPlacementOption: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$placementOptionId = placementOptionId_example; // String | 
$operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $placementOptionId = placementOptionId_example; # String | 
my $operationComplete = 1; # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

eval {
    my $result = $api_instance->confirmPlacementOption(inboundPlanId => $inboundPlanId, placementOptionId => $placementOptionId, operationComplete => $operationComplete);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->confirmPlacementOption: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
placementOptionId = placementOptionId_example # String |  (default to null)
operationComplete = 1 # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)

try:
    api_response = api_instance.confirm_placement_option(inboundPlanId, placementOptionId, operationComplete=operationComplete)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->confirmPlacementOption: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let placementOptionId = placementOptionId_example; // String
    let operationComplete = 1; // Integer

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.confirmPlacementOption(inboundPlanId, placementOptionId, operationComplete, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
placementOptionId*
String
Required
Query parameters
Name Description
operationComplete
Integer
Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

Responses

Name Type Format Description
x-request-id String

confirmShipmentContentUpdatePreview

A wrapper around Amazon's [confirmShipmentContentUpdatePreview](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#confirmshipmentcontentupdatepreview) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/contentUpdatePreviews/{contentUpdatePreviewId}/confirmation

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/contentUpdatePreviews/{contentUpdatePreviewId}/confirmation?operationComplete=1"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        String contentUpdatePreviewId = contentUpdatePreviewId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

        try {
            confirmShipmentContentUpdatePreview_200_response result = apiInstance.confirmShipmentContentUpdatePreview(inboundPlanId, shipmentId, contentUpdatePreviewId, operationComplete);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#confirmShipmentContentUpdatePreview");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String shipmentId = new String(); // String | 
final String contentUpdatePreviewId = new String(); // String | 
final Integer operationComplete = new Integer(); // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

try {
    final result = await api_instance.confirmShipmentContentUpdatePreview(inboundPlanId, shipmentId, contentUpdatePreviewId, operationComplete);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->confirmShipmentContentUpdatePreview: $e\n');
}

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        String contentUpdatePreviewId = contentUpdatePreviewId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

        try {
            confirmShipmentContentUpdatePreview_200_response result = apiInstance.confirmShipmentContentUpdatePreview(inboundPlanId, shipmentId, contentUpdatePreviewId, operationComplete);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#confirmShipmentContentUpdatePreview");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *shipmentId = shipmentId_example; //  (default to null)
String *contentUpdatePreviewId = contentUpdatePreviewId_example; //  (default to null)
Integer *operationComplete = 1; // Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)

[apiInstance confirmShipmentContentUpdatePreviewWith:inboundPlanId
    shipmentId:shipmentId
    contentUpdatePreviewId:contentUpdatePreviewId
    operationComplete:operationComplete
              completionHandler: ^(confirmShipmentContentUpdatePreview_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var shipmentId = shipmentId_example; // {String} 
var contentUpdatePreviewId = contentUpdatePreviewId_example; // {String} 
var opts = {
  'operationComplete': 1 // {Integer} Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.confirmShipmentContentUpdatePreview(inboundPlanId, shipmentId, contentUpdatePreviewId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var shipmentId = shipmentId_example;  // String |  (default to null)
            var contentUpdatePreviewId = contentUpdatePreviewId_example;  // String |  (default to null)
            var operationComplete = 1;  // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional)  (default to null)

            try {
                confirmShipmentContentUpdatePreview_200_response result = apiInstance.confirmShipmentContentUpdatePreview(inboundPlanId, shipmentId, contentUpdatePreviewId, operationComplete);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.confirmShipmentContentUpdatePreview: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$shipmentId = shipmentId_example; // String | 
$contentUpdatePreviewId = contentUpdatePreviewId_example; // String | 
$operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

try {
    $result = $api_instance->confirmShipmentContentUpdatePreview($inboundPlanId, $shipmentId, $contentUpdatePreviewId, $operationComplete);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SpApiFbaInboundApi->confirmShipmentContentUpdatePreview: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SpApiFbaInboundApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $shipmentId = shipmentId_example; # String | 
my $contentUpdatePreviewId = contentUpdatePreviewId_example; # String | 
my $operationComplete = 1; # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

eval {
    my $result = $api_instance->confirmShipmentContentUpdatePreview(inboundPlanId => $inboundPlanId, shipmentId => $shipmentId, contentUpdatePreviewId => $contentUpdatePreviewId, operationComplete => $operationComplete);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->confirmShipmentContentUpdatePreview: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
shipmentId = shipmentId_example # String |  (default to null)
contentUpdatePreviewId = contentUpdatePreviewId_example # String |  (default to null)
operationComplete = 1 # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)

try:
    api_response = api_instance.confirm_shipment_content_update_preview(inboundPlanId, shipmentId, contentUpdatePreviewId, operationComplete=operationComplete)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->confirmShipmentContentUpdatePreview: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let shipmentId = shipmentId_example; // String
    let contentUpdatePreviewId = contentUpdatePreviewId_example; // String
    let operationComplete = 1; // Integer

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.confirmShipmentContentUpdatePreview(inboundPlanId, shipmentId, contentUpdatePreviewId, operationComplete, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
shipmentId*
String
Required
contentUpdatePreviewId*
String
Required
Query parameters
Name Description
operationComplete
Integer
Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

Responses

Name Type Format Description
x-request-id String

confirmTransportationOptions

A wrapper around Amazon's [confirmTransportationOptions](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#confirmtransportationoptions) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/transportationOptions/confirmation

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/transportationOptions/confirmation?operationComplete=1" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
        ConfirmTransportationOptionsRequest confirmTransportationOptionsRequest = ; // ConfirmTransportationOptionsRequest | 

        try {
            confirmTransportationOptions_200_response result = apiInstance.confirmTransportationOptions(inboundPlanId, operationComplete, confirmTransportationOptionsRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#confirmTransportationOptions");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final Integer operationComplete = new Integer(); // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
final ConfirmTransportationOptionsRequest confirmTransportationOptionsRequest = new ConfirmTransportationOptionsRequest(); // ConfirmTransportationOptionsRequest | 

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

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
        ConfirmTransportationOptionsRequest confirmTransportationOptionsRequest = ; // ConfirmTransportationOptionsRequest | 

        try {
            confirmTransportationOptions_200_response result = apiInstance.confirmTransportationOptions(inboundPlanId, operationComplete, confirmTransportationOptionsRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#confirmTransportationOptions");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
Integer *operationComplete = 1; // Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)
ConfirmTransportationOptionsRequest *confirmTransportationOptionsRequest = ; //  (optional)

[apiInstance confirmTransportationOptionsWith:inboundPlanId
    operationComplete:operationComplete
    confirmTransportationOptionsRequest:confirmTransportationOptionsRequest
              completionHandler: ^(confirmTransportationOptions_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var opts = {
  'operationComplete': 1, // {Integer} Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
  'confirmTransportationOptionsRequest':  // {ConfirmTransportationOptionsRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.confirmTransportationOptions(inboundPlanId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var operationComplete = 1;  // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional)  (default to null)
            var confirmTransportationOptionsRequest = new ConfirmTransportationOptionsRequest(); // ConfirmTransportationOptionsRequest |  (optional) 

            try {
                confirmTransportationOptions_200_response result = apiInstance.confirmTransportationOptions(inboundPlanId, operationComplete, confirmTransportationOptionsRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.confirmTransportationOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
$confirmTransportationOptionsRequest = ; // ConfirmTransportationOptionsRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $operationComplete = 1; # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
my $confirmTransportationOptionsRequest = WWW::OPenAPIClient::Object::ConfirmTransportationOptionsRequest->new(); # ConfirmTransportationOptionsRequest | 

eval {
    my $result = $api_instance->confirmTransportationOptions(inboundPlanId => $inboundPlanId, operationComplete => $operationComplete, confirmTransportationOptionsRequest => $confirmTransportationOptionsRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->confirmTransportationOptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
operationComplete = 1 # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)
confirmTransportationOptionsRequest =  # ConfirmTransportationOptionsRequest |  (optional)

try:
    api_response = api_instance.confirm_transportation_options(inboundPlanId, operationComplete=operationComplete, confirmTransportationOptionsRequest=confirmTransportationOptionsRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->confirmTransportationOptions: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let operationComplete = 1; // Integer
    let confirmTransportationOptionsRequest = ; // ConfirmTransportationOptionsRequest

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.confirmTransportationOptions(inboundPlanId, operationComplete, confirmTransportationOptionsRequest, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
Body parameters
Name Description
confirmTransportationOptionsRequest

Query parameters
Name Description
operationComplete
Integer
Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

Responses

Name Type Format Description
x-request-id String

createInboundPlan

A wrapper around Amazon's [createInboundPlan](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#createinboundplan) API


/api/az/inbound/fba/inboundPlans

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans?operationComplete=1" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
        CreateInboundPlanRequest createInboundPlanRequest = ; // CreateInboundPlanRequest | 

        try {
            createInboundPlan_200_response result = apiInstance.createInboundPlan(operationComplete, createInboundPlanRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#createInboundPlan");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer operationComplete = new Integer(); // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
final CreateInboundPlanRequest createInboundPlanRequest = new CreateInboundPlanRequest(); // CreateInboundPlanRequest | 

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

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
        CreateInboundPlanRequest createInboundPlanRequest = ; // CreateInboundPlanRequest | 

        try {
            createInboundPlan_200_response result = apiInstance.createInboundPlan(operationComplete, createInboundPlanRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#createInboundPlan");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
Integer *operationComplete = 1; // Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)
CreateInboundPlanRequest *createInboundPlanRequest = ; //  (optional)

[apiInstance createInboundPlanWith:operationComplete
    createInboundPlanRequest:createInboundPlanRequest
              completionHandler: ^(createInboundPlan_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var opts = {
  'operationComplete': 1, // {Integer} Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
  'createInboundPlanRequest':  // {CreateInboundPlanRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createInboundPlan(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var operationComplete = 1;  // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional)  (default to null)
            var createInboundPlanRequest = new CreateInboundPlanRequest(); // CreateInboundPlanRequest |  (optional) 

            try {
                createInboundPlan_200_response result = apiInstance.createInboundPlan(operationComplete, createInboundPlanRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.createInboundPlan: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
$createInboundPlanRequest = ; // CreateInboundPlanRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $operationComplete = 1; # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
my $createInboundPlanRequest = WWW::OPenAPIClient::Object::CreateInboundPlanRequest->new(); # CreateInboundPlanRequest | 

eval {
    my $result = $api_instance->createInboundPlan(operationComplete => $operationComplete, createInboundPlanRequest => $createInboundPlanRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->createInboundPlan: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
operationComplete = 1 # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)
createInboundPlanRequest =  # CreateInboundPlanRequest |  (optional)

try:
    api_response = api_instance.create_inbound_plan(operationComplete=operationComplete, createInboundPlanRequest=createInboundPlanRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->createInboundPlan: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let operationComplete = 1; // Integer
    let createInboundPlanRequest = ; // CreateInboundPlanRequest

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.createInboundPlan(operationComplete, createInboundPlanRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
createInboundPlanRequest

Query parameters
Name Description
operationComplete
Integer
Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

Responses

Name Type Format Description
x-request-id String

createMarketplaceItemLabels

A wrapper around Amazon's [createMarketplaceItemLabels](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#createmarketplaceitemlabels) API


/api/az/inbound/fba/items/labels

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/items/labels" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        CreateMarketplaceItemLabelsRequest createMarketplaceItemLabelsRequest = ; // CreateMarketplaceItemLabelsRequest | 

        try {
            createMarketplaceItemLabels_200_response result = apiInstance.createMarketplaceItemLabels(createMarketplaceItemLabelsRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#createMarketplaceItemLabels");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreateMarketplaceItemLabelsRequest createMarketplaceItemLabelsRequest = new CreateMarketplaceItemLabelsRequest(); // CreateMarketplaceItemLabelsRequest | 

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

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        CreateMarketplaceItemLabelsRequest createMarketplaceItemLabelsRequest = ; // CreateMarketplaceItemLabelsRequest | 

        try {
            createMarketplaceItemLabels_200_response result = apiInstance.createMarketplaceItemLabels(createMarketplaceItemLabelsRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#createMarketplaceItemLabels");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
CreateMarketplaceItemLabelsRequest *createMarketplaceItemLabelsRequest = ; //  (optional)

[apiInstance createMarketplaceItemLabelsWith:createMarketplaceItemLabelsRequest
              completionHandler: ^(createMarketplaceItemLabels_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var opts = {
  'createMarketplaceItemLabelsRequest':  // {CreateMarketplaceItemLabelsRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createMarketplaceItemLabels(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var createMarketplaceItemLabelsRequest = new CreateMarketplaceItemLabelsRequest(); // CreateMarketplaceItemLabelsRequest |  (optional) 

            try {
                createMarketplaceItemLabels_200_response result = apiInstance.createMarketplaceItemLabels(createMarketplaceItemLabelsRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.createMarketplaceItemLabels: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$createMarketplaceItemLabelsRequest = ; // CreateMarketplaceItemLabelsRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $createMarketplaceItemLabelsRequest = WWW::OPenAPIClient::Object::CreateMarketplaceItemLabelsRequest->new(); # CreateMarketplaceItemLabelsRequest | 

eval {
    my $result = $api_instance->createMarketplaceItemLabels(createMarketplaceItemLabelsRequest => $createMarketplaceItemLabelsRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->createMarketplaceItemLabels: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
createMarketplaceItemLabelsRequest =  # CreateMarketplaceItemLabelsRequest |  (optional)

try:
    api_response = api_instance.create_marketplace_item_labels(createMarketplaceItemLabelsRequest=createMarketplaceItemLabelsRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->createMarketplaceItemLabels: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let createMarketplaceItemLabelsRequest = ; // CreateMarketplaceItemLabelsRequest

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.createMarketplaceItemLabels(createMarketplaceItemLabelsRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
createMarketplaceItemLabelsRequest

Responses


generateDeliveryWindowOptions

A wrapper around Amazon's [generateDeliveryWindowOptions](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#generatedeliverywindowoptions) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/deliveryWindowOptions

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/deliveryWindowOptions?operationComplete=1"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

        try {
            generateDeliveryWindowOptions_200_response result = apiInstance.generateDeliveryWindowOptions(inboundPlanId, shipmentId, operationComplete);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#generateDeliveryWindowOptions");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String shipmentId = new String(); // String | 
final Integer operationComplete = new Integer(); // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

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

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

        try {
            generateDeliveryWindowOptions_200_response result = apiInstance.generateDeliveryWindowOptions(inboundPlanId, shipmentId, operationComplete);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#generateDeliveryWindowOptions");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *shipmentId = shipmentId_example; //  (default to null)
Integer *operationComplete = 1; // Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)

[apiInstance generateDeliveryWindowOptionsWith:inboundPlanId
    shipmentId:shipmentId
    operationComplete:operationComplete
              completionHandler: ^(generateDeliveryWindowOptions_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var shipmentId = shipmentId_example; // {String} 
var opts = {
  'operationComplete': 1 // {Integer} Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.generateDeliveryWindowOptions(inboundPlanId, shipmentId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var shipmentId = shipmentId_example;  // String |  (default to null)
            var operationComplete = 1;  // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional)  (default to null)

            try {
                generateDeliveryWindowOptions_200_response result = apiInstance.generateDeliveryWindowOptions(inboundPlanId, shipmentId, operationComplete);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.generateDeliveryWindowOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$shipmentId = shipmentId_example; // String | 
$operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $shipmentId = shipmentId_example; # String | 
my $operationComplete = 1; # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

eval {
    my $result = $api_instance->generateDeliveryWindowOptions(inboundPlanId => $inboundPlanId, shipmentId => $shipmentId, operationComplete => $operationComplete);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->generateDeliveryWindowOptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
shipmentId = shipmentId_example # String |  (default to null)
operationComplete = 1 # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)

try:
    api_response = api_instance.generate_delivery_window_options(inboundPlanId, shipmentId, operationComplete=operationComplete)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->generateDeliveryWindowOptions: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let shipmentId = shipmentId_example; // String
    let operationComplete = 1; // Integer

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.generateDeliveryWindowOptions(inboundPlanId, shipmentId, operationComplete, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
shipmentId*
String
Required
Query parameters
Name Description
operationComplete
Integer
Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

Responses

Name Type Format Description
x-request-id String

generatePackingOptions

A wrapper around Amazon's [generatePackingOptions](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#generatepackingoptions) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/packingOptions

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/packingOptions?operationComplete=1&list=1"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
        Integer list = 1; // Integer | When the options have been generated, this parameter will tell the server to list those options and save them to the database before returning a success response.

        try {
            generatePackingOptions_200_response result = apiInstance.generatePackingOptions(inboundPlanId, operationComplete, list);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#generatePackingOptions");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final Integer operationComplete = new Integer(); // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
final Integer list = new Integer(); // Integer | When the options have been generated, this parameter will tell the server to list those options and save them to the database before returning a success response.

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

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
        Integer list = 1; // Integer | When the options have been generated, this parameter will tell the server to list those options and save them to the database before returning a success response.

        try {
            generatePackingOptions_200_response result = apiInstance.generatePackingOptions(inboundPlanId, operationComplete, list);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#generatePackingOptions");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
Integer *operationComplete = 1; // Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)
Integer *list = 1; // When the options have been generated, this parameter will tell the server to list those options and save them to the database before returning a success response. (optional) (default to null)

[apiInstance generatePackingOptionsWith:inboundPlanId
    operationComplete:operationComplete
    list:list
              completionHandler: ^(generatePackingOptions_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var opts = {
  'operationComplete': 1, // {Integer} Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
  'list': 1 // {Integer} When the options have been generated, this parameter will tell the server to list those options and save them to the database before returning a success response.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.generatePackingOptions(inboundPlanId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var operationComplete = 1;  // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional)  (default to null)
            var list = 1;  // Integer | When the options have been generated, this parameter will tell the server to list those options and save them to the database before returning a success response. (optional)  (default to null)

            try {
                generatePackingOptions_200_response result = apiInstance.generatePackingOptions(inboundPlanId, operationComplete, list);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.generatePackingOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
$list = 1; // Integer | When the options have been generated, this parameter will tell the server to list those options and save them to the database before returning a success response.

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $operationComplete = 1; # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
my $list = 1; # Integer | When the options have been generated, this parameter will tell the server to list those options and save them to the database before returning a success response.

eval {
    my $result = $api_instance->generatePackingOptions(inboundPlanId => $inboundPlanId, operationComplete => $operationComplete, list => $list);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->generatePackingOptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
operationComplete = 1 # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)
list = 1 # Integer | When the options have been generated, this parameter will tell the server to list those options and save them to the database before returning a success response. (optional) (default to null)

try:
    api_response = api_instance.generate_packing_options(inboundPlanId, operationComplete=operationComplete, list=list)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->generatePackingOptions: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let operationComplete = 1; // Integer
    let list = 1; // Integer

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.generatePackingOptions(inboundPlanId, operationComplete, list, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
Query parameters
Name Description
operationComplete
Integer
Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
list
Integer
When the options have been generated, this parameter will tell the server to list those options and save them to the database before returning a success response.

Responses

Name Type Format Description
x-request-id String

generatePlacementOptions

A wrapper around Amazon's [generatePlacementOptions](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#generateplacementoptions) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/placementOptions

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/placementOptions?operationComplete=1&list=1"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
        Integer list = 1; // Integer | When the options have been generated, this parameter will tell the server to list those options and save them to the database before returning a success response.

        try {
            generatePlacementOptions_200_response result = apiInstance.generatePlacementOptions(inboundPlanId, operationComplete, list);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#generatePlacementOptions");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final Integer operationComplete = new Integer(); // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
final Integer list = new Integer(); // Integer | When the options have been generated, this parameter will tell the server to list those options and save them to the database before returning a success response.

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

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
        Integer list = 1; // Integer | When the options have been generated, this parameter will tell the server to list those options and save them to the database before returning a success response.

        try {
            generatePlacementOptions_200_response result = apiInstance.generatePlacementOptions(inboundPlanId, operationComplete, list);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#generatePlacementOptions");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
Integer *operationComplete = 1; // Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)
Integer *list = 1; // When the options have been generated, this parameter will tell the server to list those options and save them to the database before returning a success response. (optional) (default to null)

[apiInstance generatePlacementOptionsWith:inboundPlanId
    operationComplete:operationComplete
    list:list
              completionHandler: ^(generatePlacementOptions_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var opts = {
  'operationComplete': 1, // {Integer} Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
  'list': 1 // {Integer} When the options have been generated, this parameter will tell the server to list those options and save them to the database before returning a success response.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.generatePlacementOptions(inboundPlanId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var operationComplete = 1;  // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional)  (default to null)
            var list = 1;  // Integer | When the options have been generated, this parameter will tell the server to list those options and save them to the database before returning a success response. (optional)  (default to null)

            try {
                generatePlacementOptions_200_response result = apiInstance.generatePlacementOptions(inboundPlanId, operationComplete, list);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.generatePlacementOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
$list = 1; // Integer | When the options have been generated, this parameter will tell the server to list those options and save them to the database before returning a success response.

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $operationComplete = 1; # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
my $list = 1; # Integer | When the options have been generated, this parameter will tell the server to list those options and save them to the database before returning a success response.

eval {
    my $result = $api_instance->generatePlacementOptions(inboundPlanId => $inboundPlanId, operationComplete => $operationComplete, list => $list);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->generatePlacementOptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
operationComplete = 1 # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)
list = 1 # Integer | When the options have been generated, this parameter will tell the server to list those options and save them to the database before returning a success response. (optional) (default to null)

try:
    api_response = api_instance.generate_placement_options(inboundPlanId, operationComplete=operationComplete, list=list)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->generatePlacementOptions: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let operationComplete = 1; // Integer
    let list = 1; // Integer

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.generatePlacementOptions(inboundPlanId, operationComplete, list, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
Query parameters
Name Description
operationComplete
Integer
Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
list
Integer
When the options have been generated, this parameter will tell the server to list those options and save them to the database before returning a success response.

Responses

Name Type Format Description
x-request-id String

generateSelfShipAppointmentSlots

A wrapper around Amazon's [generateSelfShipAppointmentSlots](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#generateselfshipappointmentslots) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/selfShipAppointmentSlots

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/selfShipAppointmentSlots?operationComplete=1" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
        GenerateSelfShipAppointmentSlotsRequest generateSelfShipAppointmentSlotsRequest = ; // GenerateSelfShipAppointmentSlotsRequest | 

        try {
            generateShipmentContentUpdatePreviews_200_response result = apiInstance.generateSelfShipAppointmentSlots(inboundPlanId, shipmentId, operationComplete, generateSelfShipAppointmentSlotsRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#generateSelfShipAppointmentSlots");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String shipmentId = new String(); // String | 
final Integer operationComplete = new Integer(); // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
final GenerateSelfShipAppointmentSlotsRequest generateSelfShipAppointmentSlotsRequest = new GenerateSelfShipAppointmentSlotsRequest(); // GenerateSelfShipAppointmentSlotsRequest | 

try {
    final result = await api_instance.generateSelfShipAppointmentSlots(inboundPlanId, shipmentId, operationComplete, generateSelfShipAppointmentSlotsRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->generateSelfShipAppointmentSlots: $e\n');
}

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
        GenerateSelfShipAppointmentSlotsRequest generateSelfShipAppointmentSlotsRequest = ; // GenerateSelfShipAppointmentSlotsRequest | 

        try {
            generateShipmentContentUpdatePreviews_200_response result = apiInstance.generateSelfShipAppointmentSlots(inboundPlanId, shipmentId, operationComplete, generateSelfShipAppointmentSlotsRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#generateSelfShipAppointmentSlots");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *shipmentId = shipmentId_example; //  (default to null)
Integer *operationComplete = 1; // Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)
GenerateSelfShipAppointmentSlotsRequest *generateSelfShipAppointmentSlotsRequest = ; //  (optional)

[apiInstance generateSelfShipAppointmentSlotsWith:inboundPlanId
    shipmentId:shipmentId
    operationComplete:operationComplete
    generateSelfShipAppointmentSlotsRequest:generateSelfShipAppointmentSlotsRequest
              completionHandler: ^(generateShipmentContentUpdatePreviews_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var shipmentId = shipmentId_example; // {String} 
var opts = {
  'operationComplete': 1, // {Integer} Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
  'generateSelfShipAppointmentSlotsRequest':  // {GenerateSelfShipAppointmentSlotsRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.generateSelfShipAppointmentSlots(inboundPlanId, shipmentId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var shipmentId = shipmentId_example;  // String |  (default to null)
            var operationComplete = 1;  // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional)  (default to null)
            var generateSelfShipAppointmentSlotsRequest = new GenerateSelfShipAppointmentSlotsRequest(); // GenerateSelfShipAppointmentSlotsRequest |  (optional) 

            try {
                generateShipmentContentUpdatePreviews_200_response result = apiInstance.generateSelfShipAppointmentSlots(inboundPlanId, shipmentId, operationComplete, generateSelfShipAppointmentSlotsRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.generateSelfShipAppointmentSlots: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$shipmentId = shipmentId_example; // String | 
$operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
$generateSelfShipAppointmentSlotsRequest = ; // GenerateSelfShipAppointmentSlotsRequest | 

try {
    $result = $api_instance->generateSelfShipAppointmentSlots($inboundPlanId, $shipmentId, $operationComplete, $generateSelfShipAppointmentSlotsRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SpApiFbaInboundApi->generateSelfShipAppointmentSlots: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SpApiFbaInboundApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $shipmentId = shipmentId_example; # String | 
my $operationComplete = 1; # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
my $generateSelfShipAppointmentSlotsRequest = WWW::OPenAPIClient::Object::GenerateSelfShipAppointmentSlotsRequest->new(); # GenerateSelfShipAppointmentSlotsRequest | 

eval {
    my $result = $api_instance->generateSelfShipAppointmentSlots(inboundPlanId => $inboundPlanId, shipmentId => $shipmentId, operationComplete => $operationComplete, generateSelfShipAppointmentSlotsRequest => $generateSelfShipAppointmentSlotsRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->generateSelfShipAppointmentSlots: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
shipmentId = shipmentId_example # String |  (default to null)
operationComplete = 1 # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)
generateSelfShipAppointmentSlotsRequest =  # GenerateSelfShipAppointmentSlotsRequest |  (optional)

try:
    api_response = api_instance.generate_self_ship_appointment_slots(inboundPlanId, shipmentId, operationComplete=operationComplete, generateSelfShipAppointmentSlotsRequest=generateSelfShipAppointmentSlotsRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->generateSelfShipAppointmentSlots: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let shipmentId = shipmentId_example; // String
    let operationComplete = 1; // Integer
    let generateSelfShipAppointmentSlotsRequest = ; // GenerateSelfShipAppointmentSlotsRequest

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.generateSelfShipAppointmentSlots(inboundPlanId, shipmentId, operationComplete, generateSelfShipAppointmentSlotsRequest, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
shipmentId*
String
Required
Body parameters
Name Description
generateSelfShipAppointmentSlotsRequest

Query parameters
Name Description
operationComplete
Integer
Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

Responses

Name Type Format Description
x-request-id String

generateShipmentContentUpdatePreviews

A wrapper around Amazon's [generateShipmentContentUpdatePreviews](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#generateshipmentcontentupdatepreviews) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/contentUpdatePreviews

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/contentUpdatePreviews?operationComplete=1" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
        GenerateShipmentContentUpdatePreviewsRequest generateShipmentContentUpdatePreviewsRequest = ; // GenerateShipmentContentUpdatePreviewsRequest | 

        try {
            generateShipmentContentUpdatePreviews_200_response result = apiInstance.generateShipmentContentUpdatePreviews(inboundPlanId, shipmentId, operationComplete, generateShipmentContentUpdatePreviewsRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#generateShipmentContentUpdatePreviews");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String shipmentId = new String(); // String | 
final Integer operationComplete = new Integer(); // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
final GenerateShipmentContentUpdatePreviewsRequest generateShipmentContentUpdatePreviewsRequest = new GenerateShipmentContentUpdatePreviewsRequest(); // GenerateShipmentContentUpdatePreviewsRequest | 

try {
    final result = await api_instance.generateShipmentContentUpdatePreviews(inboundPlanId, shipmentId, operationComplete, generateShipmentContentUpdatePreviewsRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->generateShipmentContentUpdatePreviews: $e\n');
}

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
        GenerateShipmentContentUpdatePreviewsRequest generateShipmentContentUpdatePreviewsRequest = ; // GenerateShipmentContentUpdatePreviewsRequest | 

        try {
            generateShipmentContentUpdatePreviews_200_response result = apiInstance.generateShipmentContentUpdatePreviews(inboundPlanId, shipmentId, operationComplete, generateShipmentContentUpdatePreviewsRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#generateShipmentContentUpdatePreviews");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *shipmentId = shipmentId_example; //  (default to null)
Integer *operationComplete = 1; // Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)
GenerateShipmentContentUpdatePreviewsRequest *generateShipmentContentUpdatePreviewsRequest = ; //  (optional)

[apiInstance generateShipmentContentUpdatePreviewsWith:inboundPlanId
    shipmentId:shipmentId
    operationComplete:operationComplete
    generateShipmentContentUpdatePreviewsRequest:generateShipmentContentUpdatePreviewsRequest
              completionHandler: ^(generateShipmentContentUpdatePreviews_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var shipmentId = shipmentId_example; // {String} 
var opts = {
  'operationComplete': 1, // {Integer} Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
  'generateShipmentContentUpdatePreviewsRequest':  // {GenerateShipmentContentUpdatePreviewsRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.generateShipmentContentUpdatePreviews(inboundPlanId, shipmentId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var shipmentId = shipmentId_example;  // String |  (default to null)
            var operationComplete = 1;  // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional)  (default to null)
            var generateShipmentContentUpdatePreviewsRequest = new GenerateShipmentContentUpdatePreviewsRequest(); // GenerateShipmentContentUpdatePreviewsRequest |  (optional) 

            try {
                generateShipmentContentUpdatePreviews_200_response result = apiInstance.generateShipmentContentUpdatePreviews(inboundPlanId, shipmentId, operationComplete, generateShipmentContentUpdatePreviewsRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.generateShipmentContentUpdatePreviews: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$shipmentId = shipmentId_example; // String | 
$operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
$generateShipmentContentUpdatePreviewsRequest = ; // GenerateShipmentContentUpdatePreviewsRequest | 

try {
    $result = $api_instance->generateShipmentContentUpdatePreviews($inboundPlanId, $shipmentId, $operationComplete, $generateShipmentContentUpdatePreviewsRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SpApiFbaInboundApi->generateShipmentContentUpdatePreviews: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SpApiFbaInboundApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $shipmentId = shipmentId_example; # String | 
my $operationComplete = 1; # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
my $generateShipmentContentUpdatePreviewsRequest = WWW::OPenAPIClient::Object::GenerateShipmentContentUpdatePreviewsRequest->new(); # GenerateShipmentContentUpdatePreviewsRequest | 

eval {
    my $result = $api_instance->generateShipmentContentUpdatePreviews(inboundPlanId => $inboundPlanId, shipmentId => $shipmentId, operationComplete => $operationComplete, generateShipmentContentUpdatePreviewsRequest => $generateShipmentContentUpdatePreviewsRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->generateShipmentContentUpdatePreviews: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
shipmentId = shipmentId_example # String |  (default to null)
operationComplete = 1 # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)
generateShipmentContentUpdatePreviewsRequest =  # GenerateShipmentContentUpdatePreviewsRequest |  (optional)

try:
    api_response = api_instance.generate_shipment_content_update_previews(inboundPlanId, shipmentId, operationComplete=operationComplete, generateShipmentContentUpdatePreviewsRequest=generateShipmentContentUpdatePreviewsRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->generateShipmentContentUpdatePreviews: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let shipmentId = shipmentId_example; // String
    let operationComplete = 1; // Integer
    let generateShipmentContentUpdatePreviewsRequest = ; // GenerateShipmentContentUpdatePreviewsRequest

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.generateShipmentContentUpdatePreviews(inboundPlanId, shipmentId, operationComplete, generateShipmentContentUpdatePreviewsRequest, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
shipmentId*
String
Required
Body parameters
Name Description
generateShipmentContentUpdatePreviewsRequest

Query parameters
Name Description
operationComplete
Integer
Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

Responses

Name Type Format Description
x-request-id String

generateTransportationOptions

A wrapper around Amazon's [generateTransportationOptions](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#generatetransportationoptions) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/transportationOptions

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/transportationOptions?operationComplete=1&list=1" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
        Integer list = 1; // Integer | When the options have been generated, this parameter will tell the server to list those options and save them to the database before returning a success response.
        GenerateTransportationOptionsRequest generateTransportationOptionsRequest = ; // GenerateTransportationOptionsRequest | 

        try {
            generateTransportationOptions_200_response result = apiInstance.generateTransportationOptions(inboundPlanId, operationComplete, list, generateTransportationOptionsRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#generateTransportationOptions");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final Integer operationComplete = new Integer(); // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
final Integer list = new Integer(); // Integer | When the options have been generated, this parameter will tell the server to list those options and save them to the database before returning a success response.
final GenerateTransportationOptionsRequest generateTransportationOptionsRequest = new GenerateTransportationOptionsRequest(); // GenerateTransportationOptionsRequest | 

try {
    final result = await api_instance.generateTransportationOptions(inboundPlanId, operationComplete, list, generateTransportationOptionsRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->generateTransportationOptions: $e\n');
}

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
        Integer list = 1; // Integer | When the options have been generated, this parameter will tell the server to list those options and save them to the database before returning a success response.
        GenerateTransportationOptionsRequest generateTransportationOptionsRequest = ; // GenerateTransportationOptionsRequest | 

        try {
            generateTransportationOptions_200_response result = apiInstance.generateTransportationOptions(inboundPlanId, operationComplete, list, generateTransportationOptionsRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#generateTransportationOptions");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
Integer *operationComplete = 1; // Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)
Integer *list = 1; // When the options have been generated, this parameter will tell the server to list those options and save them to the database before returning a success response. (optional) (default to null)
GenerateTransportationOptionsRequest *generateTransportationOptionsRequest = ; //  (optional)

[apiInstance generateTransportationOptionsWith:inboundPlanId
    operationComplete:operationComplete
    list:list
    generateTransportationOptionsRequest:generateTransportationOptionsRequest
              completionHandler: ^(generateTransportationOptions_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var opts = {
  'operationComplete': 1, // {Integer} Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
  'list': 1, // {Integer} When the options have been generated, this parameter will tell the server to list those options and save them to the database before returning a success response.
  'generateTransportationOptionsRequest':  // {GenerateTransportationOptionsRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.generateTransportationOptions(inboundPlanId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var operationComplete = 1;  // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional)  (default to null)
            var list = 1;  // Integer | When the options have been generated, this parameter will tell the server to list those options and save them to the database before returning a success response. (optional)  (default to null)
            var generateTransportationOptionsRequest = new GenerateTransportationOptionsRequest(); // GenerateTransportationOptionsRequest |  (optional) 

            try {
                generateTransportationOptions_200_response result = apiInstance.generateTransportationOptions(inboundPlanId, operationComplete, list, generateTransportationOptionsRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.generateTransportationOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
$list = 1; // Integer | When the options have been generated, this parameter will tell the server to list those options and save them to the database before returning a success response.
$generateTransportationOptionsRequest = ; // GenerateTransportationOptionsRequest | 

try {
    $result = $api_instance->generateTransportationOptions($inboundPlanId, $operationComplete, $list, $generateTransportationOptionsRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SpApiFbaInboundApi->generateTransportationOptions: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SpApiFbaInboundApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $operationComplete = 1; # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
my $list = 1; # Integer | When the options have been generated, this parameter will tell the server to list those options and save them to the database before returning a success response.
my $generateTransportationOptionsRequest = WWW::OPenAPIClient::Object::GenerateTransportationOptionsRequest->new(); # GenerateTransportationOptionsRequest | 

eval {
    my $result = $api_instance->generateTransportationOptions(inboundPlanId => $inboundPlanId, operationComplete => $operationComplete, list => $list, generateTransportationOptionsRequest => $generateTransportationOptionsRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->generateTransportationOptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
operationComplete = 1 # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)
list = 1 # Integer | When the options have been generated, this parameter will tell the server to list those options and save them to the database before returning a success response. (optional) (default to null)
generateTransportationOptionsRequest =  # GenerateTransportationOptionsRequest |  (optional)

try:
    api_response = api_instance.generate_transportation_options(inboundPlanId, operationComplete=operationComplete, list=list, generateTransportationOptionsRequest=generateTransportationOptionsRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->generateTransportationOptions: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let operationComplete = 1; // Integer
    let list = 1; // Integer
    let generateTransportationOptionsRequest = ; // GenerateTransportationOptionsRequest

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.generateTransportationOptions(inboundPlanId, operationComplete, list, generateTransportationOptionsRequest, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
Body parameters
Name Description
generateTransportationOptionsRequest

Query parameters
Name Description
operationComplete
Integer
Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
list
Integer
When the options have been generated, this parameter will tell the server to list those options and save them to the database before returning a success response.

Responses

Name Type Format Description
x-request-id String

getBillOfLading

A wrapper around Amazon's [getBillOfLading](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v0-reference#getbilloflading) API


/api/az/inbound/fba/shipments/{shipmentId}/billOfLading

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/shipments/{shipmentId}/billOfLading"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String shipmentId = shipmentId_example; // String | 

        try {
            getBillOfLading_200_response result = apiInstance.getBillOfLading(shipmentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#getBillOfLading");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String shipmentId = new String(); // String | 

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

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String shipmentId = shipmentId_example; // String | 

        try {
            getBillOfLading_200_response result = apiInstance.getBillOfLading(shipmentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#getBillOfLading");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *shipmentId = shipmentId_example; //  (default to null)

[apiInstance getBillOfLadingWith:shipmentId
              completionHandler: ^(getBillOfLading_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var shipmentId = shipmentId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getBillOfLading(shipmentId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var shipmentId = shipmentId_example;  // String |  (default to null)

            try {
                getBillOfLading_200_response result = apiInstance.getBillOfLading(shipmentId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.getBillOfLading: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$shipmentId = shipmentId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $shipmentId = shipmentId_example; # String | 

eval {
    my $result = $api_instance->getBillOfLading(shipmentId => $shipmentId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->getBillOfLading: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
shipmentId = shipmentId_example # String |  (default to null)

try:
    api_response = api_instance.get_bill_of_lading(shipmentId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->getBillOfLading: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let shipmentId = shipmentId_example; // String

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.getBillOfLading(shipmentId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
shipmentId*
String
Required

Responses


getDeliveryChallanDocument

A wrapper around Amazon's [getDeliveryChallanDocument](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#getdeliverychallandocument) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/deliveryChallanDocument

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/deliveryChallanDocument"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 

        try {
            getDeliveryChallanDocument_200_response result = apiInstance.getDeliveryChallanDocument(inboundPlanId, shipmentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#getDeliveryChallanDocument");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String shipmentId = new String(); // String | 

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

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 

        try {
            getDeliveryChallanDocument_200_response result = apiInstance.getDeliveryChallanDocument(inboundPlanId, shipmentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#getDeliveryChallanDocument");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *shipmentId = shipmentId_example; //  (default to null)

[apiInstance getDeliveryChallanDocumentWith:inboundPlanId
    shipmentId:shipmentId
              completionHandler: ^(getDeliveryChallanDocument_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var shipmentId = shipmentId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getDeliveryChallanDocument(inboundPlanId, shipmentId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var shipmentId = shipmentId_example;  // String |  (default to null)

            try {
                getDeliveryChallanDocument_200_response result = apiInstance.getDeliveryChallanDocument(inboundPlanId, shipmentId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.getDeliveryChallanDocument: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$shipmentId = shipmentId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $shipmentId = shipmentId_example; # String | 

eval {
    my $result = $api_instance->getDeliveryChallanDocument(inboundPlanId => $inboundPlanId, shipmentId => $shipmentId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->getDeliveryChallanDocument: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
shipmentId = shipmentId_example # String |  (default to null)

try:
    api_response = api_instance.get_delivery_challan_document(inboundPlanId, shipmentId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->getDeliveryChallanDocument: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let shipmentId = shipmentId_example; // String

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.getDeliveryChallanDocument(inboundPlanId, shipmentId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
shipmentId*
String
Required

Responses


getInboundOperationStatus

A wrapper around Amazon's [getInboundOperationStatus](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#getinboundoperationstatus) API


/api/az/inbound/fba/operations/{operationId}

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/operations/{operationId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String operationId = operationId_example; // String | 

        try {
            spapi.InboundOperationStatus result = apiInstance.getInboundOperationStatus(operationId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#getInboundOperationStatus");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String operationId = new String(); // String | 

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

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String operationId = operationId_example; // String | 

        try {
            spapi.InboundOperationStatus result = apiInstance.getInboundOperationStatus(operationId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#getInboundOperationStatus");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *operationId = operationId_example; //  (default to null)

[apiInstance getInboundOperationStatusWith:operationId
              completionHandler: ^(spapi.InboundOperationStatus output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var operationId = operationId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getInboundOperationStatus(operationId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var operationId = operationId_example;  // String |  (default to null)

            try {
                spapi.InboundOperationStatus result = apiInstance.getInboundOperationStatus(operationId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.getInboundOperationStatus: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$operationId = operationId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $operationId = operationId_example; # String | 

eval {
    my $result = $api_instance->getInboundOperationStatus(operationId => $operationId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->getInboundOperationStatus: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
operationId = operationId_example # String |  (default to null)

try:
    api_response = api_instance.get_inbound_operation_status(operationId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->getInboundOperationStatus: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let operationId = operationId_example; // String

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.getInboundOperationStatus(operationId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
operationId*
String
Required

Responses


getInboundPlan

A wrapper around Amazon's [getInboundPlan](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#getinboundplan) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 

        try {
            getInboundPlan_200_response result = apiInstance.getInboundPlan(inboundPlanId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#getInboundPlan");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 

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

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 

        try {
            getInboundPlan_200_response result = apiInstance.getInboundPlan(inboundPlanId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#getInboundPlan");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)

[apiInstance getInboundPlanWith:inboundPlanId
              completionHandler: ^(getInboundPlan_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getInboundPlan(inboundPlanId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)

            try {
                getInboundPlan_200_response result = apiInstance.getInboundPlan(inboundPlanId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.getInboundPlan: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 

eval {
    my $result = $api_instance->getInboundPlan(inboundPlanId => $inboundPlanId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->getInboundPlan: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)

try:
    api_response = api_instance.get_inbound_plan(inboundPlanId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->getInboundPlan: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.getInboundPlan(inboundPlanId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required

Responses


getLabels

A wrapper around Amazon's [getLabels](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v0-reference#getlabels) API


/api/az/inbound/fba/shipments/{shipmentId}/labels

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/shipments/{shipmentId}/labels?PageType=pageType_example&LabelType=labelType_example&NumberOfPackages=56&PackageLabelsToPrint =&NumberOfPallets=56&PageSize=56&PageStartIndex=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String shipmentId = shipmentId_example; // String | 
        String pageType = pageType_example; // String | 
        String labelType = labelType_example; // String | 
        Integer numberOfPackages = 56; // Integer | 
        array[String] packageLabelsToPrint  = ; // array[String] | 
        Integer numberOfPallets = 56; // Integer | 
        Integer pageSize = 56; // Integer | 
        Integer pageStartIndex = 56; // Integer | 

        try {
            getLabels_200_response result = apiInstance.getLabels(shipmentId, pageType, labelType, numberOfPackages, packageLabelsToPrint , numberOfPallets, pageSize, pageStartIndex);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#getLabels");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String shipmentId = new String(); // String | 
final String pageType = new String(); // String | 
final String labelType = new String(); // String | 
final Integer numberOfPackages = new Integer(); // Integer | 
final array[String] packageLabelsToPrint  = new array[String](); // array[String] | 
final Integer numberOfPallets = new Integer(); // Integer | 
final Integer pageSize = new Integer(); // Integer | 
final Integer pageStartIndex = new Integer(); // Integer | 

try {
    final result = await api_instance.getLabels(shipmentId, pageType, labelType, numberOfPackages, packageLabelsToPrint , numberOfPallets, pageSize, pageStartIndex);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getLabels: $e\n');
}

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String shipmentId = shipmentId_example; // String | 
        String pageType = pageType_example; // String | 
        String labelType = labelType_example; // String | 
        Integer numberOfPackages = 56; // Integer | 
        array[String] packageLabelsToPrint  = ; // array[String] | 
        Integer numberOfPallets = 56; // Integer | 
        Integer pageSize = 56; // Integer | 
        Integer pageStartIndex = 56; // Integer | 

        try {
            getLabels_200_response result = apiInstance.getLabels(shipmentId, pageType, labelType, numberOfPackages, packageLabelsToPrint , numberOfPallets, pageSize, pageStartIndex);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#getLabels");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *shipmentId = shipmentId_example; //  (default to null)
String *pageType = pageType_example; //  (default to null)
String *labelType = labelType_example; //  (default to null)
Integer *numberOfPackages = 56; //  (optional) (default to null)
array[String] *packageLabelsToPrint  = ; //  (optional) (default to null)
Integer *numberOfPallets = 56; //  (optional) (default to null)
Integer *pageSize = 56; //  (optional) (default to null)
Integer *pageStartIndex = 56; //  (optional) (default to null)

[apiInstance getLabelsWith:shipmentId
    pageType:pageType
    labelType:labelType
    numberOfPackages:numberOfPackages
    packageLabelsToPrint :packageLabelsToPrint 
    numberOfPallets:numberOfPallets
    pageSize:pageSize
    pageStartIndex:pageStartIndex
              completionHandler: ^(getLabels_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var shipmentId = shipmentId_example; // {String} 
var pageType = pageType_example; // {String} 
var labelType = labelType_example; // {String} 
var opts = {
  'numberOfPackages': 56, // {Integer} 
  'packageLabelsToPrint ': , // {array[String]} 
  'numberOfPallets': 56, // {Integer} 
  'pageSize': 56, // {Integer} 
  'pageStartIndex': 56 // {Integer} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getLabels(shipmentId, pageType, labelType, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var shipmentId = shipmentId_example;  // String |  (default to null)
            var pageType = pageType_example;  // String |  (default to null)
            var labelType = labelType_example;  // String |  (default to null)
            var numberOfPackages = 56;  // Integer |  (optional)  (default to null)
            var packageLabelsToPrint  = new array[String](); // array[String] |  (optional)  (default to null)
            var numberOfPallets = 56;  // Integer |  (optional)  (default to null)
            var pageSize = 56;  // Integer |  (optional)  (default to null)
            var pageStartIndex = 56;  // Integer |  (optional)  (default to null)

            try {
                getLabels_200_response result = apiInstance.getLabels(shipmentId, pageType, labelType, numberOfPackages, packageLabelsToPrint , numberOfPallets, pageSize, pageStartIndex);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.getLabels: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$shipmentId = shipmentId_example; // String | 
$pageType = pageType_example; // String | 
$labelType = labelType_example; // String | 
$numberOfPackages = 56; // Integer | 
$packageLabelsToPrint  = ; // array[String] | 
$numberOfPallets = 56; // Integer | 
$pageSize = 56; // Integer | 
$pageStartIndex = 56; // Integer | 

try {
    $result = $api_instance->getLabels($shipmentId, $pageType, $labelType, $numberOfPackages, $packageLabelsToPrint , $numberOfPallets, $pageSize, $pageStartIndex);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SpApiFbaInboundApi->getLabels: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SpApiFbaInboundApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $shipmentId = shipmentId_example; # String | 
my $pageType = pageType_example; # String | 
my $labelType = labelType_example; # String | 
my $numberOfPackages = 56; # Integer | 
my $packageLabelsToPrint  = []; # array[String] | 
my $numberOfPallets = 56; # Integer | 
my $pageSize = 56; # Integer | 
my $pageStartIndex = 56; # Integer | 

eval {
    my $result = $api_instance->getLabels(shipmentId => $shipmentId, pageType => $pageType, labelType => $labelType, numberOfPackages => $numberOfPackages, packageLabelsToPrint  => $packageLabelsToPrint , numberOfPallets => $numberOfPallets, pageSize => $pageSize, pageStartIndex => $pageStartIndex);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->getLabels: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
shipmentId = shipmentId_example # String |  (default to null)
pageType = pageType_example # String |  (default to null)
labelType = labelType_example # String |  (default to null)
numberOfPackages = 56 # Integer |  (optional) (default to null)
packageLabelsToPrint  =  # array[String] |  (optional) (default to null)
numberOfPallets = 56 # Integer |  (optional) (default to null)
pageSize = 56 # Integer |  (optional) (default to null)
pageStartIndex = 56 # Integer |  (optional) (default to null)

try:
    api_response = api_instance.get_labels(shipmentId, pageType, labelType, numberOfPackages=numberOfPackages, packageLabelsToPrint =packageLabelsToPrint , numberOfPallets=numberOfPallets, pageSize=pageSize, pageStartIndex=pageStartIndex)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->getLabels: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let shipmentId = shipmentId_example; // String
    let pageType = pageType_example; // String
    let labelType = labelType_example; // String
    let numberOfPackages = 56; // Integer
    let packageLabelsToPrint  = ; // array[String]
    let numberOfPallets = 56; // Integer
    let pageSize = 56; // Integer
    let pageStartIndex = 56; // Integer

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.getLabels(shipmentId, pageType, labelType, numberOfPackages, packageLabelsToPrint , numberOfPallets, pageSize, pageStartIndex, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
shipmentId*
String
Required
Query parameters
Name Description
PageType*
String
Required
LabelType*
String
Required
NumberOfPackages
Integer
PackageLabelsToPrint
array[String]
NumberOfPallets
Integer
PageSize
Integer
PageStartIndex
Integer

Responses


getSelfShipAppointmentSlots

A wrapper around Amazon's [getSelfShipAppointmentSlots](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#getselfshipappointmentslots) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/selfShipAppointmentSlots

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/selfShipAppointmentSlots?pageSize=10&paginationToken=paginationToken_example&allPages=1"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        Integer pageSize = 10; // Integer | 
        String paginationToken = paginationToken_example; // String | 
        Integer allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

        try {
            getSelfShipAppointmentSlots_200_response result = apiInstance.getSelfShipAppointmentSlots(inboundPlanId, shipmentId, pageSize, paginationToken, allPages);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#getSelfShipAppointmentSlots");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String shipmentId = new String(); // String | 
final Integer pageSize = new Integer(); // Integer | 
final String paginationToken = new String(); // String | 
final Integer allPages = new Integer(); // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

try {
    final result = await api_instance.getSelfShipAppointmentSlots(inboundPlanId, shipmentId, pageSize, paginationToken, allPages);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getSelfShipAppointmentSlots: $e\n');
}

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        Integer pageSize = 10; // Integer | 
        String paginationToken = paginationToken_example; // String | 
        Integer allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

        try {
            getSelfShipAppointmentSlots_200_response result = apiInstance.getSelfShipAppointmentSlots(inboundPlanId, shipmentId, pageSize, paginationToken, allPages);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#getSelfShipAppointmentSlots");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *shipmentId = shipmentId_example; //  (default to null)
Integer *pageSize = 10; //  (optional) (default to null)
String *paginationToken = paginationToken_example; //  (optional) (default to null)
Integer *allPages = 1; // Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional) (default to null)

[apiInstance getSelfShipAppointmentSlotsWith:inboundPlanId
    shipmentId:shipmentId
    pageSize:pageSize
    paginationToken:paginationToken
    allPages:allPages
              completionHandler: ^(getSelfShipAppointmentSlots_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var shipmentId = shipmentId_example; // {String} 
var opts = {
  'pageSize': 10, // {Integer} 
  'paginationToken': paginationToken_example, // {String} 
  'allPages': 1 // {Integer} Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSelfShipAppointmentSlots(inboundPlanId, shipmentId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var shipmentId = shipmentId_example;  // String |  (default to null)
            var pageSize = 10;  // Integer |  (optional)  (default to null)
            var paginationToken = paginationToken_example;  // String |  (optional)  (default to null)
            var allPages = 1;  // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional)  (default to null)

            try {
                getSelfShipAppointmentSlots_200_response result = apiInstance.getSelfShipAppointmentSlots(inboundPlanId, shipmentId, pageSize, paginationToken, allPages);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.getSelfShipAppointmentSlots: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$shipmentId = shipmentId_example; // String | 
$pageSize = 10; // Integer | 
$paginationToken = paginationToken_example; // String | 
$allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

try {
    $result = $api_instance->getSelfShipAppointmentSlots($inboundPlanId, $shipmentId, $pageSize, $paginationToken, $allPages);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SpApiFbaInboundApi->getSelfShipAppointmentSlots: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SpApiFbaInboundApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $shipmentId = shipmentId_example; # String | 
my $pageSize = 10; # Integer | 
my $paginationToken = paginationToken_example; # String | 
my $allPages = 1; # Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

eval {
    my $result = $api_instance->getSelfShipAppointmentSlots(inboundPlanId => $inboundPlanId, shipmentId => $shipmentId, pageSize => $pageSize, paginationToken => $paginationToken, allPages => $allPages);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->getSelfShipAppointmentSlots: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
shipmentId = shipmentId_example # String |  (default to null)
pageSize = 10 # Integer |  (optional) (default to null)
paginationToken = paginationToken_example # String |  (optional) (default to null)
allPages = 1 # Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional) (default to null)

try:
    api_response = api_instance.get_self_ship_appointment_slots(inboundPlanId, shipmentId, pageSize=pageSize, paginationToken=paginationToken, allPages=allPages)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->getSelfShipAppointmentSlots: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let shipmentId = shipmentId_example; // String
    let pageSize = 10; // Integer
    let paginationToken = paginationToken_example; // String
    let allPages = 1; // Integer

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.getSelfShipAppointmentSlots(inboundPlanId, shipmentId, pageSize, paginationToken, allPages, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
shipmentId*
String
Required
Query parameters
Name Description
pageSize
Integer
paginationToken
String
allPages
Integer
Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

Responses


getShipment

A wrapper around Amazon's [getShipment](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#getshipment) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 

        try {
            spapi.Shipment result = apiInstance.getShipment(inboundPlanId, shipmentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#getShipment");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String shipmentId = new String(); // String | 

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

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 

        try {
            spapi.Shipment result = apiInstance.getShipment(inboundPlanId, shipmentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#getShipment");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *shipmentId = shipmentId_example; //  (default to null)

[apiInstance getShipmentWith:inboundPlanId
    shipmentId:shipmentId
              completionHandler: ^(spapi.Shipment output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var shipmentId = shipmentId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getShipment(inboundPlanId, shipmentId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var shipmentId = shipmentId_example;  // String |  (default to null)

            try {
                spapi.Shipment result = apiInstance.getShipment(inboundPlanId, shipmentId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.getShipment: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$shipmentId = shipmentId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $shipmentId = shipmentId_example; # String | 

eval {
    my $result = $api_instance->getShipment(inboundPlanId => $inboundPlanId, shipmentId => $shipmentId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->getShipment: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
shipmentId = shipmentId_example # String |  (default to null)

try:
    api_response = api_instance.get_shipment(inboundPlanId, shipmentId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->getShipment: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let shipmentId = shipmentId_example; // String

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.getShipment(inboundPlanId, shipmentId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
shipmentId*
String
Required

Responses


getShipmentContentUpdatePreview

A wrapper around Amazon's [getShipmentContentUpdatePreview](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#getshipmentcontentupdatepreview) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/contentUpdatePreviews/{contentUpdatePreviewId}

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/contentUpdatePreviews/{contentUpdatePreviewId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        String contentUpdatePreviewId = contentUpdatePreviewId_example; // String | 

        try {
            listShipmentContentUpdatePreviews_200_response_contentUpdatePreviews_inner result = apiInstance.getShipmentContentUpdatePreview(inboundPlanId, shipmentId, contentUpdatePreviewId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#getShipmentContentUpdatePreview");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String shipmentId = new String(); // String | 
final String contentUpdatePreviewId = new String(); // String | 

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

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        String contentUpdatePreviewId = contentUpdatePreviewId_example; // String | 

        try {
            listShipmentContentUpdatePreviews_200_response_contentUpdatePreviews_inner result = apiInstance.getShipmentContentUpdatePreview(inboundPlanId, shipmentId, contentUpdatePreviewId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#getShipmentContentUpdatePreview");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *shipmentId = shipmentId_example; //  (default to null)
String *contentUpdatePreviewId = contentUpdatePreviewId_example; //  (default to null)

[apiInstance getShipmentContentUpdatePreviewWith:inboundPlanId
    shipmentId:shipmentId
    contentUpdatePreviewId:contentUpdatePreviewId
              completionHandler: ^(listShipmentContentUpdatePreviews_200_response_contentUpdatePreviews_inner output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var shipmentId = shipmentId_example; // {String} 
var contentUpdatePreviewId = contentUpdatePreviewId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getShipmentContentUpdatePreview(inboundPlanId, shipmentId, contentUpdatePreviewId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var shipmentId = shipmentId_example;  // String |  (default to null)
            var contentUpdatePreviewId = contentUpdatePreviewId_example;  // String |  (default to null)

            try {
                listShipmentContentUpdatePreviews_200_response_contentUpdatePreviews_inner result = apiInstance.getShipmentContentUpdatePreview(inboundPlanId, shipmentId, contentUpdatePreviewId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.getShipmentContentUpdatePreview: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$shipmentId = shipmentId_example; // String | 
$contentUpdatePreviewId = contentUpdatePreviewId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $shipmentId = shipmentId_example; # String | 
my $contentUpdatePreviewId = contentUpdatePreviewId_example; # String | 

eval {
    my $result = $api_instance->getShipmentContentUpdatePreview(inboundPlanId => $inboundPlanId, shipmentId => $shipmentId, contentUpdatePreviewId => $contentUpdatePreviewId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->getShipmentContentUpdatePreview: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
shipmentId = shipmentId_example # String |  (default to null)
contentUpdatePreviewId = contentUpdatePreviewId_example # String |  (default to null)

try:
    api_response = api_instance.get_shipment_content_update_preview(inboundPlanId, shipmentId, contentUpdatePreviewId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->getShipmentContentUpdatePreview: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let shipmentId = shipmentId_example; // String
    let contentUpdatePreviewId = contentUpdatePreviewId_example; // String

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.getShipmentContentUpdatePreview(inboundPlanId, shipmentId, contentUpdatePreviewId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
shipmentId*
String
Required
contentUpdatePreviewId*
String
Required

Responses


listDeliveryWindowOptions

A wrapper around Amazon's [listDeliveryWindowOptions](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#listdeliverywindowoptions) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/deliveryWindowOptions

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/deliveryWindowOptions?pageSize=10&paginationToken=paginationToken_example&allPages=1"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        Integer pageSize = 10; // Integer | 
        String paginationToken = paginationToken_example; // String | 
        Integer allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

        try {
            listDeliveryWindowOptions_200_response result = apiInstance.listDeliveryWindowOptions(inboundPlanId, shipmentId, pageSize, paginationToken, allPages);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listDeliveryWindowOptions");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String shipmentId = new String(); // String | 
final Integer pageSize = new Integer(); // Integer | 
final String paginationToken = new String(); // String | 
final Integer allPages = new Integer(); // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

try {
    final result = await api_instance.listDeliveryWindowOptions(inboundPlanId, shipmentId, pageSize, paginationToken, allPages);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listDeliveryWindowOptions: $e\n');
}

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        Integer pageSize = 10; // Integer | 
        String paginationToken = paginationToken_example; // String | 
        Integer allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

        try {
            listDeliveryWindowOptions_200_response result = apiInstance.listDeliveryWindowOptions(inboundPlanId, shipmentId, pageSize, paginationToken, allPages);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listDeliveryWindowOptions");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *shipmentId = shipmentId_example; //  (default to null)
Integer *pageSize = 10; //  (optional) (default to null)
String *paginationToken = paginationToken_example; //  (optional) (default to null)
Integer *allPages = 1; // Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional) (default to null)

[apiInstance listDeliveryWindowOptionsWith:inboundPlanId
    shipmentId:shipmentId
    pageSize:pageSize
    paginationToken:paginationToken
    allPages:allPages
              completionHandler: ^(listDeliveryWindowOptions_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var shipmentId = shipmentId_example; // {String} 
var opts = {
  'pageSize': 10, // {Integer} 
  'paginationToken': paginationToken_example, // {String} 
  'allPages': 1 // {Integer} Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listDeliveryWindowOptions(inboundPlanId, shipmentId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var shipmentId = shipmentId_example;  // String |  (default to null)
            var pageSize = 10;  // Integer |  (optional)  (default to null)
            var paginationToken = paginationToken_example;  // String |  (optional)  (default to null)
            var allPages = 1;  // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional)  (default to null)

            try {
                listDeliveryWindowOptions_200_response result = apiInstance.listDeliveryWindowOptions(inboundPlanId, shipmentId, pageSize, paginationToken, allPages);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.listDeliveryWindowOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$shipmentId = shipmentId_example; // String | 
$pageSize = 10; // Integer | 
$paginationToken = paginationToken_example; // String | 
$allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

try {
    $result = $api_instance->listDeliveryWindowOptions($inboundPlanId, $shipmentId, $pageSize, $paginationToken, $allPages);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SpApiFbaInboundApi->listDeliveryWindowOptions: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SpApiFbaInboundApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $shipmentId = shipmentId_example; # String | 
my $pageSize = 10; # Integer | 
my $paginationToken = paginationToken_example; # String | 
my $allPages = 1; # Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

eval {
    my $result = $api_instance->listDeliveryWindowOptions(inboundPlanId => $inboundPlanId, shipmentId => $shipmentId, pageSize => $pageSize, paginationToken => $paginationToken, allPages => $allPages);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->listDeliveryWindowOptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
shipmentId = shipmentId_example # String |  (default to null)
pageSize = 10 # Integer |  (optional) (default to null)
paginationToken = paginationToken_example # String |  (optional) (default to null)
allPages = 1 # Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional) (default to null)

try:
    api_response = api_instance.list_delivery_window_options(inboundPlanId, shipmentId, pageSize=pageSize, paginationToken=paginationToken, allPages=allPages)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->listDeliveryWindowOptions: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let shipmentId = shipmentId_example; // String
    let pageSize = 10; // Integer
    let paginationToken = paginationToken_example; // String
    let allPages = 1; // Integer

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.listDeliveryWindowOptions(inboundPlanId, shipmentId, pageSize, paginationToken, allPages, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
shipmentId*
String
Required
Query parameters
Name Description
pageSize
Integer
paginationToken
String
allPages
Integer
Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

Responses


listInboundPlanBoxes

A wrapper around Amazon's [listInboundPlanBoxes](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#listinboundplanboxes) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/boxes

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/boxes?pageSize=10&paginationToken=paginationToken_example&allPages=1"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        Integer pageSize = 10; // Integer | 
        String paginationToken = paginationToken_example; // String | 
        Integer allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

        try {
            listInboundPlanBoxes_200_response result = apiInstance.listInboundPlanBoxes(inboundPlanId, pageSize, paginationToken, allPages);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listInboundPlanBoxes");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final Integer pageSize = new Integer(); // Integer | 
final String paginationToken = new String(); // String | 
final Integer allPages = new Integer(); // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

try {
    final result = await api_instance.listInboundPlanBoxes(inboundPlanId, pageSize, paginationToken, allPages);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listInboundPlanBoxes: $e\n');
}

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        Integer pageSize = 10; // Integer | 
        String paginationToken = paginationToken_example; // String | 
        Integer allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

        try {
            listInboundPlanBoxes_200_response result = apiInstance.listInboundPlanBoxes(inboundPlanId, pageSize, paginationToken, allPages);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listInboundPlanBoxes");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
Integer *pageSize = 10; //  (optional) (default to null)
String *paginationToken = paginationToken_example; //  (optional) (default to null)
Integer *allPages = 1; // Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional) (default to null)

[apiInstance listInboundPlanBoxesWith:inboundPlanId
    pageSize:pageSize
    paginationToken:paginationToken
    allPages:allPages
              completionHandler: ^(listInboundPlanBoxes_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var opts = {
  'pageSize': 10, // {Integer} 
  'paginationToken': paginationToken_example, // {String} 
  'allPages': 1 // {Integer} Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listInboundPlanBoxes(inboundPlanId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var pageSize = 10;  // Integer |  (optional)  (default to null)
            var paginationToken = paginationToken_example;  // String |  (optional)  (default to null)
            var allPages = 1;  // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional)  (default to null)

            try {
                listInboundPlanBoxes_200_response result = apiInstance.listInboundPlanBoxes(inboundPlanId, pageSize, paginationToken, allPages);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.listInboundPlanBoxes: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$pageSize = 10; // Integer | 
$paginationToken = paginationToken_example; // String | 
$allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

try {
    $result = $api_instance->listInboundPlanBoxes($inboundPlanId, $pageSize, $paginationToken, $allPages);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SpApiFbaInboundApi->listInboundPlanBoxes: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SpApiFbaInboundApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $pageSize = 10; # Integer | 
my $paginationToken = paginationToken_example; # String | 
my $allPages = 1; # Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

eval {
    my $result = $api_instance->listInboundPlanBoxes(inboundPlanId => $inboundPlanId, pageSize => $pageSize, paginationToken => $paginationToken, allPages => $allPages);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->listInboundPlanBoxes: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
pageSize = 10 # Integer |  (optional) (default to null)
paginationToken = paginationToken_example # String |  (optional) (default to null)
allPages = 1 # Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional) (default to null)

try:
    api_response = api_instance.list_inbound_plan_boxes(inboundPlanId, pageSize=pageSize, paginationToken=paginationToken, allPages=allPages)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->listInboundPlanBoxes: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let pageSize = 10; // Integer
    let paginationToken = paginationToken_example; // String
    let allPages = 1; // Integer

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.listInboundPlanBoxes(inboundPlanId, pageSize, paginationToken, allPages, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
Query parameters
Name Description
pageSize
Integer
paginationToken
String
allPages
Integer
Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

Responses


listInboundPlanItems

A wrapper around Amazon's [listInboundPlanItems](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#listinboundplanitems) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/items

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/items?pageSize=10&paginationToken=paginationToken_example&allPages=1"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        Integer pageSize = 10; // Integer | 
        String paginationToken = paginationToken_example; // String | 
        Integer allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

        try {
            listInboundPlanItems_200_response result = apiInstance.listInboundPlanItems(inboundPlanId, pageSize, paginationToken, allPages);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listInboundPlanItems");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final Integer pageSize = new Integer(); // Integer | 
final String paginationToken = new String(); // String | 
final Integer allPages = new Integer(); // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

try {
    final result = await api_instance.listInboundPlanItems(inboundPlanId, pageSize, paginationToken, allPages);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listInboundPlanItems: $e\n');
}

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        Integer pageSize = 10; // Integer | 
        String paginationToken = paginationToken_example; // String | 
        Integer allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

        try {
            listInboundPlanItems_200_response result = apiInstance.listInboundPlanItems(inboundPlanId, pageSize, paginationToken, allPages);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listInboundPlanItems");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
Integer *pageSize = 10; //  (optional) (default to null)
String *paginationToken = paginationToken_example; //  (optional) (default to null)
Integer *allPages = 1; // Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional) (default to null)

[apiInstance listInboundPlanItemsWith:inboundPlanId
    pageSize:pageSize
    paginationToken:paginationToken
    allPages:allPages
              completionHandler: ^(listInboundPlanItems_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var opts = {
  'pageSize': 10, // {Integer} 
  'paginationToken': paginationToken_example, // {String} 
  'allPages': 1 // {Integer} Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listInboundPlanItems(inboundPlanId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var pageSize = 10;  // Integer |  (optional)  (default to null)
            var paginationToken = paginationToken_example;  // String |  (optional)  (default to null)
            var allPages = 1;  // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional)  (default to null)

            try {
                listInboundPlanItems_200_response result = apiInstance.listInboundPlanItems(inboundPlanId, pageSize, paginationToken, allPages);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.listInboundPlanItems: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$pageSize = 10; // Integer | 
$paginationToken = paginationToken_example; // String | 
$allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

try {
    $result = $api_instance->listInboundPlanItems($inboundPlanId, $pageSize, $paginationToken, $allPages);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SpApiFbaInboundApi->listInboundPlanItems: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SpApiFbaInboundApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $pageSize = 10; # Integer | 
my $paginationToken = paginationToken_example; # String | 
my $allPages = 1; # Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

eval {
    my $result = $api_instance->listInboundPlanItems(inboundPlanId => $inboundPlanId, pageSize => $pageSize, paginationToken => $paginationToken, allPages => $allPages);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->listInboundPlanItems: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
pageSize = 10 # Integer |  (optional) (default to null)
paginationToken = paginationToken_example # String |  (optional) (default to null)
allPages = 1 # Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional) (default to null)

try:
    api_response = api_instance.list_inbound_plan_items(inboundPlanId, pageSize=pageSize, paginationToken=paginationToken, allPages=allPages)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->listInboundPlanItems: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let pageSize = 10; // Integer
    let paginationToken = paginationToken_example; // String
    let allPages = 1; // Integer

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.listInboundPlanItems(inboundPlanId, pageSize, paginationToken, allPages, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
Query parameters
Name Description
pageSize
Integer
paginationToken
String
allPages
Integer
Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

Responses


listInboundPlanPallets

A wrapper around Amazon's [listInboundPlanPallets](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#listinboundplanpallets) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/pallets

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/pallets?pageSize=10&paginationToken=paginationToken_example&allPages=1"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        Integer pageSize = 10; // Integer | 
        String paginationToken = paginationToken_example; // String | 
        Integer allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

        try {
            listInboundPlanPallets_200_response result = apiInstance.listInboundPlanPallets(inboundPlanId, pageSize, paginationToken, allPages);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listInboundPlanPallets");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final Integer pageSize = new Integer(); // Integer | 
final String paginationToken = new String(); // String | 
final Integer allPages = new Integer(); // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

try {
    final result = await api_instance.listInboundPlanPallets(inboundPlanId, pageSize, paginationToken, allPages);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listInboundPlanPallets: $e\n');
}

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        Integer pageSize = 10; // Integer | 
        String paginationToken = paginationToken_example; // String | 
        Integer allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

        try {
            listInboundPlanPallets_200_response result = apiInstance.listInboundPlanPallets(inboundPlanId, pageSize, paginationToken, allPages);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listInboundPlanPallets");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
Integer *pageSize = 10; //  (optional) (default to null)
String *paginationToken = paginationToken_example; //  (optional) (default to null)
Integer *allPages = 1; // Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional) (default to null)

[apiInstance listInboundPlanPalletsWith:inboundPlanId
    pageSize:pageSize
    paginationToken:paginationToken
    allPages:allPages
              completionHandler: ^(listInboundPlanPallets_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var opts = {
  'pageSize': 10, // {Integer} 
  'paginationToken': paginationToken_example, // {String} 
  'allPages': 1 // {Integer} Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listInboundPlanPallets(inboundPlanId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var pageSize = 10;  // Integer |  (optional)  (default to null)
            var paginationToken = paginationToken_example;  // String |  (optional)  (default to null)
            var allPages = 1;  // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional)  (default to null)

            try {
                listInboundPlanPallets_200_response result = apiInstance.listInboundPlanPallets(inboundPlanId, pageSize, paginationToken, allPages);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.listInboundPlanPallets: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$pageSize = 10; // Integer | 
$paginationToken = paginationToken_example; // String | 
$allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

try {
    $result = $api_instance->listInboundPlanPallets($inboundPlanId, $pageSize, $paginationToken, $allPages);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SpApiFbaInboundApi->listInboundPlanPallets: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SpApiFbaInboundApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $pageSize = 10; # Integer | 
my $paginationToken = paginationToken_example; # String | 
my $allPages = 1; # Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

eval {
    my $result = $api_instance->listInboundPlanPallets(inboundPlanId => $inboundPlanId, pageSize => $pageSize, paginationToken => $paginationToken, allPages => $allPages);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->listInboundPlanPallets: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
pageSize = 10 # Integer |  (optional) (default to null)
paginationToken = paginationToken_example # String |  (optional) (default to null)
allPages = 1 # Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional) (default to null)

try:
    api_response = api_instance.list_inbound_plan_pallets(inboundPlanId, pageSize=pageSize, paginationToken=paginationToken, allPages=allPages)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->listInboundPlanPallets: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let pageSize = 10; // Integer
    let paginationToken = paginationToken_example; // String
    let allPages = 1; // Integer

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.listInboundPlanPallets(inboundPlanId, pageSize, paginationToken, allPages, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
Query parameters
Name Description
pageSize
Integer
paginationToken
String
allPages
Integer
Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

Responses


listInboundPlans

A wrapper around Amazon's [listInboundPlans](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#listinboundplans) API


/api/az/inbound/fba/inboundPlans

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans?pageSize=10&paginationToken=paginationToken_example&status=status_example&sortBy=sortBy_example&sortOrder=sortOrder_example&allPages=1"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        Integer pageSize = 10; // Integer | 
        String paginationToken = paginationToken_example; // String | 
        String status = status_example; // String | 
        String sortBy = sortBy_example; // String | 
        String sortOrder = sortOrder_example; // String | 
        Integer allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

        try {
            listInboundPlans_200_response result = apiInstance.listInboundPlans(pageSize, paginationToken, status, sortBy, sortOrder, allPages);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listInboundPlans");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer pageSize = new Integer(); // Integer | 
final String paginationToken = new String(); // String | 
final String status = new String(); // String | 
final String sortBy = new String(); // String | 
final String sortOrder = new String(); // String | 
final Integer allPages = new Integer(); // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

try {
    final result = await api_instance.listInboundPlans(pageSize, paginationToken, status, sortBy, sortOrder, allPages);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listInboundPlans: $e\n');
}

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        Integer pageSize = 10; // Integer | 
        String paginationToken = paginationToken_example; // String | 
        String status = status_example; // String | 
        String sortBy = sortBy_example; // String | 
        String sortOrder = sortOrder_example; // String | 
        Integer allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

        try {
            listInboundPlans_200_response result = apiInstance.listInboundPlans(pageSize, paginationToken, status, sortBy, sortOrder, allPages);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listInboundPlans");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
Integer *pageSize = 10; //  (optional) (default to null)
String *paginationToken = paginationToken_example; //  (optional) (default to null)
String *status = status_example; //  (optional) (default to null)
String *sortBy = sortBy_example; //  (optional) (default to null)
String *sortOrder = sortOrder_example; //  (optional) (default to null)
Integer *allPages = 1; // Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional) (default to null)

[apiInstance listInboundPlansWith:pageSize
    paginationToken:paginationToken
    status:status
    sortBy:sortBy
    sortOrder:sortOrder
    allPages:allPages
              completionHandler: ^(listInboundPlans_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var opts = {
  'pageSize': 10, // {Integer} 
  'paginationToken': paginationToken_example, // {String} 
  'status': status_example, // {String} 
  'sortBy': sortBy_example, // {String} 
  'sortOrder': sortOrder_example, // {String} 
  'allPages': 1 // {Integer} Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listInboundPlans(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var pageSize = 10;  // Integer |  (optional)  (default to null)
            var paginationToken = paginationToken_example;  // String |  (optional)  (default to null)
            var status = status_example;  // String |  (optional)  (default to null)
            var sortBy = sortBy_example;  // String |  (optional)  (default to null)
            var sortOrder = sortOrder_example;  // String |  (optional)  (default to null)
            var allPages = 1;  // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional)  (default to null)

            try {
                listInboundPlans_200_response result = apiInstance.listInboundPlans(pageSize, paginationToken, status, sortBy, sortOrder, allPages);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.listInboundPlans: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$pageSize = 10; // Integer | 
$paginationToken = paginationToken_example; // String | 
$status = status_example; // String | 
$sortBy = sortBy_example; // String | 
$sortOrder = sortOrder_example; // String | 
$allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

try {
    $result = $api_instance->listInboundPlans($pageSize, $paginationToken, $status, $sortBy, $sortOrder, $allPages);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SpApiFbaInboundApi->listInboundPlans: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SpApiFbaInboundApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $pageSize = 10; # Integer | 
my $paginationToken = paginationToken_example; # String | 
my $status = status_example; # String | 
my $sortBy = sortBy_example; # String | 
my $sortOrder = sortOrder_example; # String | 
my $allPages = 1; # Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

eval {
    my $result = $api_instance->listInboundPlans(pageSize => $pageSize, paginationToken => $paginationToken, status => $status, sortBy => $sortBy, sortOrder => $sortOrder, allPages => $allPages);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->listInboundPlans: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
pageSize = 10 # Integer |  (optional) (default to null)
paginationToken = paginationToken_example # String |  (optional) (default to null)
status = status_example # String |  (optional) (default to null)
sortBy = sortBy_example # String |  (optional) (default to null)
sortOrder = sortOrder_example # String |  (optional) (default to null)
allPages = 1 # Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional) (default to null)

try:
    api_response = api_instance.list_inbound_plans(pageSize=pageSize, paginationToken=paginationToken, status=status, sortBy=sortBy, sortOrder=sortOrder, allPages=allPages)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->listInboundPlans: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let pageSize = 10; // Integer
    let paginationToken = paginationToken_example; // String
    let status = status_example; // String
    let sortBy = sortBy_example; // String
    let sortOrder = sortOrder_example; // String
    let allPages = 1; // Integer

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.listInboundPlans(pageSize, paginationToken, status, sortBy, sortOrder, allPages, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
pageSize
Integer
paginationToken
String
status
String
sortBy
String
sortOrder
String
allPages
Integer
Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

Responses


listItemComplianceDetails

A wrapper around Amazon's [listItemComplianceDetails](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#listitemcompliancedetails) API


/api/az/inbound/fba/items/compliance

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/items/compliance?mskus=&marketplaceId=marketplaceId_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        array[String] mskus = ; // array[String] | 
        String marketplaceId = marketplaceId_example; // String | 

        try {
            listItemComplianceDetails_200_response result = apiInstance.listItemComplianceDetails(mskus, marketplaceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listItemComplianceDetails");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final array[String] mskus = new array[String](); // array[String] | 
final String marketplaceId = new String(); // String | 

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

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        array[String] mskus = ; // array[String] | 
        String marketplaceId = marketplaceId_example; // String | 

        try {
            listItemComplianceDetails_200_response result = apiInstance.listItemComplianceDetails(mskus, marketplaceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listItemComplianceDetails");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
array[String] *mskus = ; //  (default to null)
String *marketplaceId = marketplaceId_example; //  (default to null)

[apiInstance listItemComplianceDetailsWith:mskus
    marketplaceId:marketplaceId
              completionHandler: ^(listItemComplianceDetails_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var mskus = ; // {array[String]} 
var marketplaceId = marketplaceId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listItemComplianceDetails(mskus, marketplaceId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var mskus = new array[String](); // array[String] |  (default to null)
            var marketplaceId = marketplaceId_example;  // String |  (default to null)

            try {
                listItemComplianceDetails_200_response result = apiInstance.listItemComplianceDetails(mskus, marketplaceId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.listItemComplianceDetails: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$mskus = ; // array[String] | 
$marketplaceId = marketplaceId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $mskus = []; # array[String] | 
my $marketplaceId = marketplaceId_example; # String | 

eval {
    my $result = $api_instance->listItemComplianceDetails(mskus => $mskus, marketplaceId => $marketplaceId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->listItemComplianceDetails: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
mskus =  # array[String] |  (default to null)
marketplaceId = marketplaceId_example # String |  (default to null)

try:
    api_response = api_instance.list_item_compliance_details(mskus, marketplaceId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->listItemComplianceDetails: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let mskus = ; // array[String]
    let marketplaceId = marketplaceId_example; // String

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.listItemComplianceDetails(mskus, marketplaceId, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
mskus*
array[String]
Required
marketplaceId*
String
Required

Responses


listPackingGroupBoxes

A wrapper around Amazon's [listPackingGroupBoxes](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#listpackinggroupboxes) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/packingGroups/{packingGroupId}/boxes

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/packingGroups/{packingGroupId}/boxes?pageSize=10&paginationToken=paginationToken_example&allPages=1"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String packingGroupId = packingGroupId_example; // String | 
        Integer pageSize = 10; // Integer | 
        String paginationToken = paginationToken_example; // String | 
        Integer allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

        try {
            listPackingGroupBoxes_200_response result = apiInstance.listPackingGroupBoxes(inboundPlanId, packingGroupId, pageSize, paginationToken, allPages);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listPackingGroupBoxes");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String packingGroupId = new String(); // String | 
final Integer pageSize = new Integer(); // Integer | 
final String paginationToken = new String(); // String | 
final Integer allPages = new Integer(); // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

try {
    final result = await api_instance.listPackingGroupBoxes(inboundPlanId, packingGroupId, pageSize, paginationToken, allPages);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listPackingGroupBoxes: $e\n');
}

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String packingGroupId = packingGroupId_example; // String | 
        Integer pageSize = 10; // Integer | 
        String paginationToken = paginationToken_example; // String | 
        Integer allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

        try {
            listPackingGroupBoxes_200_response result = apiInstance.listPackingGroupBoxes(inboundPlanId, packingGroupId, pageSize, paginationToken, allPages);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listPackingGroupBoxes");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *packingGroupId = packingGroupId_example; //  (default to null)
Integer *pageSize = 10; //  (optional) (default to null)
String *paginationToken = paginationToken_example; //  (optional) (default to null)
Integer *allPages = 1; // Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional) (default to null)

[apiInstance listPackingGroupBoxesWith:inboundPlanId
    packingGroupId:packingGroupId
    pageSize:pageSize
    paginationToken:paginationToken
    allPages:allPages
              completionHandler: ^(listPackingGroupBoxes_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var packingGroupId = packingGroupId_example; // {String} 
var opts = {
  'pageSize': 10, // {Integer} 
  'paginationToken': paginationToken_example, // {String} 
  'allPages': 1 // {Integer} Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listPackingGroupBoxes(inboundPlanId, packingGroupId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var packingGroupId = packingGroupId_example;  // String |  (default to null)
            var pageSize = 10;  // Integer |  (optional)  (default to null)
            var paginationToken = paginationToken_example;  // String |  (optional)  (default to null)
            var allPages = 1;  // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional)  (default to null)

            try {
                listPackingGroupBoxes_200_response result = apiInstance.listPackingGroupBoxes(inboundPlanId, packingGroupId, pageSize, paginationToken, allPages);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.listPackingGroupBoxes: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$packingGroupId = packingGroupId_example; // String | 
$pageSize = 10; // Integer | 
$paginationToken = paginationToken_example; // String | 
$allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

try {
    $result = $api_instance->listPackingGroupBoxes($inboundPlanId, $packingGroupId, $pageSize, $paginationToken, $allPages);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SpApiFbaInboundApi->listPackingGroupBoxes: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SpApiFbaInboundApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $packingGroupId = packingGroupId_example; # String | 
my $pageSize = 10; # Integer | 
my $paginationToken = paginationToken_example; # String | 
my $allPages = 1; # Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

eval {
    my $result = $api_instance->listPackingGroupBoxes(inboundPlanId => $inboundPlanId, packingGroupId => $packingGroupId, pageSize => $pageSize, paginationToken => $paginationToken, allPages => $allPages);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->listPackingGroupBoxes: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
packingGroupId = packingGroupId_example # String |  (default to null)
pageSize = 10 # Integer |  (optional) (default to null)
paginationToken = paginationToken_example # String |  (optional) (default to null)
allPages = 1 # Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional) (default to null)

try:
    api_response = api_instance.list_packing_group_boxes(inboundPlanId, packingGroupId, pageSize=pageSize, paginationToken=paginationToken, allPages=allPages)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->listPackingGroupBoxes: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let packingGroupId = packingGroupId_example; // String
    let pageSize = 10; // Integer
    let paginationToken = paginationToken_example; // String
    let allPages = 1; // Integer

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.listPackingGroupBoxes(inboundPlanId, packingGroupId, pageSize, paginationToken, allPages, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
packingGroupId*
String
Required
Query parameters
Name Description
pageSize
Integer
paginationToken
String
allPages
Integer
Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

Responses


listPackingGroupItems

A wrapper around Amazon's [listPackingGroupItems](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#listpackinggroupitems) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/packingGroups/{packingGroupId}/items

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/packingGroups/{packingGroupId}/items?pageSize=10&paginationToken=paginationToken_example&allPages=1"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String packingGroupId = packingGroupId_example; // String | 
        Integer pageSize = 10; // Integer | 
        String paginationToken = paginationToken_example; // String | 
        Integer allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

        try {
            listPackingGroupItems_200_response result = apiInstance.listPackingGroupItems(inboundPlanId, packingGroupId, pageSize, paginationToken, allPages);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listPackingGroupItems");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String packingGroupId = new String(); // String | 
final Integer pageSize = new Integer(); // Integer | 
final String paginationToken = new String(); // String | 
final Integer allPages = new Integer(); // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

try {
    final result = await api_instance.listPackingGroupItems(inboundPlanId, packingGroupId, pageSize, paginationToken, allPages);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listPackingGroupItems: $e\n');
}

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String packingGroupId = packingGroupId_example; // String | 
        Integer pageSize = 10; // Integer | 
        String paginationToken = paginationToken_example; // String | 
        Integer allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

        try {
            listPackingGroupItems_200_response result = apiInstance.listPackingGroupItems(inboundPlanId, packingGroupId, pageSize, paginationToken, allPages);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listPackingGroupItems");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *packingGroupId = packingGroupId_example; //  (default to null)
Integer *pageSize = 10; //  (optional) (default to null)
String *paginationToken = paginationToken_example; //  (optional) (default to null)
Integer *allPages = 1; // Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional) (default to null)

[apiInstance listPackingGroupItemsWith:inboundPlanId
    packingGroupId:packingGroupId
    pageSize:pageSize
    paginationToken:paginationToken
    allPages:allPages
              completionHandler: ^(listPackingGroupItems_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var packingGroupId = packingGroupId_example; // {String} 
var opts = {
  'pageSize': 10, // {Integer} 
  'paginationToken': paginationToken_example, // {String} 
  'allPages': 1 // {Integer} Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listPackingGroupItems(inboundPlanId, packingGroupId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var packingGroupId = packingGroupId_example;  // String |  (default to null)
            var pageSize = 10;  // Integer |  (optional)  (default to null)
            var paginationToken = paginationToken_example;  // String |  (optional)  (default to null)
            var allPages = 1;  // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional)  (default to null)

            try {
                listPackingGroupItems_200_response result = apiInstance.listPackingGroupItems(inboundPlanId, packingGroupId, pageSize, paginationToken, allPages);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.listPackingGroupItems: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$packingGroupId = packingGroupId_example; // String | 
$pageSize = 10; // Integer | 
$paginationToken = paginationToken_example; // String | 
$allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

try {
    $result = $api_instance->listPackingGroupItems($inboundPlanId, $packingGroupId, $pageSize, $paginationToken, $allPages);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SpApiFbaInboundApi->listPackingGroupItems: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SpApiFbaInboundApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $packingGroupId = packingGroupId_example; # String | 
my $pageSize = 10; # Integer | 
my $paginationToken = paginationToken_example; # String | 
my $allPages = 1; # Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

eval {
    my $result = $api_instance->listPackingGroupItems(inboundPlanId => $inboundPlanId, packingGroupId => $packingGroupId, pageSize => $pageSize, paginationToken => $paginationToken, allPages => $allPages);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->listPackingGroupItems: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
packingGroupId = packingGroupId_example # String |  (default to null)
pageSize = 10 # Integer |  (optional) (default to null)
paginationToken = paginationToken_example # String |  (optional) (default to null)
allPages = 1 # Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional) (default to null)

try:
    api_response = api_instance.list_packing_group_items(inboundPlanId, packingGroupId, pageSize=pageSize, paginationToken=paginationToken, allPages=allPages)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->listPackingGroupItems: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let packingGroupId = packingGroupId_example; // String
    let pageSize = 10; // Integer
    let paginationToken = paginationToken_example; // String
    let allPages = 1; // Integer

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.listPackingGroupItems(inboundPlanId, packingGroupId, pageSize, paginationToken, allPages, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
packingGroupId*
String
Required
Query parameters
Name Description
pageSize
Integer
paginationToken
String
allPages
Integer
Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

Responses


listPackingOptions

A wrapper around Amazon's [listPackingOptions](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#listpackingoptions) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/packingOptions

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/packingOptions?pageSize=10&paginationToken=paginationToken_example&allPages=1"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        Integer pageSize = 10; // Integer | 
        String paginationToken = paginationToken_example; // String | 
        Integer allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

        try {
            listPackingOptions_200_response result = apiInstance.listPackingOptions(inboundPlanId, pageSize, paginationToken, allPages);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listPackingOptions");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final Integer pageSize = new Integer(); // Integer | 
final String paginationToken = new String(); // String | 
final Integer allPages = new Integer(); // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

try {
    final result = await api_instance.listPackingOptions(inboundPlanId, pageSize, paginationToken, allPages);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listPackingOptions: $e\n');
}

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        Integer pageSize = 10; // Integer | 
        String paginationToken = paginationToken_example; // String | 
        Integer allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

        try {
            listPackingOptions_200_response result = apiInstance.listPackingOptions(inboundPlanId, pageSize, paginationToken, allPages);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listPackingOptions");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
Integer *pageSize = 10; //  (optional) (default to null)
String *paginationToken = paginationToken_example; //  (optional) (default to null)
Integer *allPages = 1; // Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional) (default to null)

[apiInstance listPackingOptionsWith:inboundPlanId
    pageSize:pageSize
    paginationToken:paginationToken
    allPages:allPages
              completionHandler: ^(listPackingOptions_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var opts = {
  'pageSize': 10, // {Integer} 
  'paginationToken': paginationToken_example, // {String} 
  'allPages': 1 // {Integer} Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listPackingOptions(inboundPlanId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var pageSize = 10;  // Integer |  (optional)  (default to null)
            var paginationToken = paginationToken_example;  // String |  (optional)  (default to null)
            var allPages = 1;  // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional)  (default to null)

            try {
                listPackingOptions_200_response result = apiInstance.listPackingOptions(inboundPlanId, pageSize, paginationToken, allPages);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.listPackingOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$pageSize = 10; // Integer | 
$paginationToken = paginationToken_example; // String | 
$allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

try {
    $result = $api_instance->listPackingOptions($inboundPlanId, $pageSize, $paginationToken, $allPages);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SpApiFbaInboundApi->listPackingOptions: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SpApiFbaInboundApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $pageSize = 10; # Integer | 
my $paginationToken = paginationToken_example; # String | 
my $allPages = 1; # Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

eval {
    my $result = $api_instance->listPackingOptions(inboundPlanId => $inboundPlanId, pageSize => $pageSize, paginationToken => $paginationToken, allPages => $allPages);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->listPackingOptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
pageSize = 10 # Integer |  (optional) (default to null)
paginationToken = paginationToken_example # String |  (optional) (default to null)
allPages = 1 # Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional) (default to null)

try:
    api_response = api_instance.list_packing_options(inboundPlanId, pageSize=pageSize, paginationToken=paginationToken, allPages=allPages)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->listPackingOptions: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let pageSize = 10; // Integer
    let paginationToken = paginationToken_example; // String
    let allPages = 1; // Integer

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.listPackingOptions(inboundPlanId, pageSize, paginationToken, allPages, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
Query parameters
Name Description
pageSize
Integer
paginationToken
String
allPages
Integer
Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

Responses


listPlacementOptions

A wrapper around Amazon's [listPlacementOptions](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#listplacementoptions) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/placementOptions

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/placementOptions?pageSize=10&paginationToken=paginationToken_example&allPages=1"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        Integer pageSize = 10; // Integer | 
        String paginationToken = paginationToken_example; // String | 
        Integer allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

        try {
            listPlacementOptions_200_response result = apiInstance.listPlacementOptions(inboundPlanId, pageSize, paginationToken, allPages);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listPlacementOptions");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final Integer pageSize = new Integer(); // Integer | 
final String paginationToken = new String(); // String | 
final Integer allPages = new Integer(); // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

try {
    final result = await api_instance.listPlacementOptions(inboundPlanId, pageSize, paginationToken, allPages);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listPlacementOptions: $e\n');
}

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        Integer pageSize = 10; // Integer | 
        String paginationToken = paginationToken_example; // String | 
        Integer allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

        try {
            listPlacementOptions_200_response result = apiInstance.listPlacementOptions(inboundPlanId, pageSize, paginationToken, allPages);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listPlacementOptions");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
Integer *pageSize = 10; //  (optional) (default to null)
String *paginationToken = paginationToken_example; //  (optional) (default to null)
Integer *allPages = 1; // Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional) (default to null)

[apiInstance listPlacementOptionsWith:inboundPlanId
    pageSize:pageSize
    paginationToken:paginationToken
    allPages:allPages
              completionHandler: ^(listPlacementOptions_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var opts = {
  'pageSize': 10, // {Integer} 
  'paginationToken': paginationToken_example, // {String} 
  'allPages': 1 // {Integer} Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listPlacementOptions(inboundPlanId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var pageSize = 10;  // Integer |  (optional)  (default to null)
            var paginationToken = paginationToken_example;  // String |  (optional)  (default to null)
            var allPages = 1;  // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional)  (default to null)

            try {
                listPlacementOptions_200_response result = apiInstance.listPlacementOptions(inboundPlanId, pageSize, paginationToken, allPages);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.listPlacementOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$pageSize = 10; // Integer | 
$paginationToken = paginationToken_example; // String | 
$allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

try {
    $result = $api_instance->listPlacementOptions($inboundPlanId, $pageSize, $paginationToken, $allPages);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SpApiFbaInboundApi->listPlacementOptions: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SpApiFbaInboundApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $pageSize = 10; # Integer | 
my $paginationToken = paginationToken_example; # String | 
my $allPages = 1; # Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

eval {
    my $result = $api_instance->listPlacementOptions(inboundPlanId => $inboundPlanId, pageSize => $pageSize, paginationToken => $paginationToken, allPages => $allPages);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->listPlacementOptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
pageSize = 10 # Integer |  (optional) (default to null)
paginationToken = paginationToken_example # String |  (optional) (default to null)
allPages = 1 # Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional) (default to null)

try:
    api_response = api_instance.list_placement_options(inboundPlanId, pageSize=pageSize, paginationToken=paginationToken, allPages=allPages)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->listPlacementOptions: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let pageSize = 10; // Integer
    let paginationToken = paginationToken_example; // String
    let allPages = 1; // Integer

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.listPlacementOptions(inboundPlanId, pageSize, paginationToken, allPages, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
Query parameters
Name Description
pageSize
Integer
paginationToken
String
allPages
Integer
Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

Responses


listPrepDetails

A wrapper around Amazon's [listPrepDetails](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#listprepdetails) API


/api/az/inbound/fba/items/prepDetails

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/items/prepDetails?marketplaceId=marketplaceId_example&mskus="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String marketplaceId = marketplaceId_example; // String | 
        array[String] mskus = ; // array[String] | 

        try {
            listPrepDetails_200_response result = apiInstance.listPrepDetails(marketplaceId, mskus);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listPrepDetails");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String marketplaceId = new String(); // String | 
final array[String] mskus = new array[String](); // array[String] | 

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

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String marketplaceId = marketplaceId_example; // String | 
        array[String] mskus = ; // array[String] | 

        try {
            listPrepDetails_200_response result = apiInstance.listPrepDetails(marketplaceId, mskus);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listPrepDetails");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *marketplaceId = marketplaceId_example; //  (default to null)
array[String] *mskus = ; //  (default to null)

[apiInstance listPrepDetailsWith:marketplaceId
    mskus:mskus
              completionHandler: ^(listPrepDetails_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var marketplaceId = marketplaceId_example; // {String} 
var mskus = ; // {array[String]} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listPrepDetails(marketplaceId, mskus, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var marketplaceId = marketplaceId_example;  // String |  (default to null)
            var mskus = new array[String](); // array[String] |  (default to null)

            try {
                listPrepDetails_200_response result = apiInstance.listPrepDetails(marketplaceId, mskus);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.listPrepDetails: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$marketplaceId = marketplaceId_example; // String | 
$mskus = ; // array[String] | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $marketplaceId = marketplaceId_example; # String | 
my $mskus = []; # array[String] | 

eval {
    my $result = $api_instance->listPrepDetails(marketplaceId => $marketplaceId, mskus => $mskus);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->listPrepDetails: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
marketplaceId = marketplaceId_example # String |  (default to null)
mskus =  # array[String] |  (default to null)

try:
    api_response = api_instance.list_prep_details(marketplaceId, mskus)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->listPrepDetails: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let marketplaceId = marketplaceId_example; // String
    let mskus = ; // array[String]

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.listPrepDetails(marketplaceId, mskus, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
marketplaceId*
String
Required
mskus*
array[String]
Required

Responses


listShipmentBoxes

A wrapper around Amazon's [listShipmentBoxes](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#listshipmentboxes) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/boxes

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/boxes?pageSize=10&paginationToken=paginationToken_example&allPages=1"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        Integer pageSize = 10; // Integer | 
        String paginationToken = paginationToken_example; // String | 
        Integer allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

        try {
            listShipmentBoxes_200_response result = apiInstance.listShipmentBoxes(inboundPlanId, shipmentId, pageSize, paginationToken, allPages);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listShipmentBoxes");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String shipmentId = new String(); // String | 
final Integer pageSize = new Integer(); // Integer | 
final String paginationToken = new String(); // String | 
final Integer allPages = new Integer(); // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

try {
    final result = await api_instance.listShipmentBoxes(inboundPlanId, shipmentId, pageSize, paginationToken, allPages);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listShipmentBoxes: $e\n');
}

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        Integer pageSize = 10; // Integer | 
        String paginationToken = paginationToken_example; // String | 
        Integer allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

        try {
            listShipmentBoxes_200_response result = apiInstance.listShipmentBoxes(inboundPlanId, shipmentId, pageSize, paginationToken, allPages);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listShipmentBoxes");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *shipmentId = shipmentId_example; //  (default to null)
Integer *pageSize = 10; //  (optional) (default to null)
String *paginationToken = paginationToken_example; //  (optional) (default to null)
Integer *allPages = 1; // Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional) (default to null)

[apiInstance listShipmentBoxesWith:inboundPlanId
    shipmentId:shipmentId
    pageSize:pageSize
    paginationToken:paginationToken
    allPages:allPages
              completionHandler: ^(listShipmentBoxes_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var shipmentId = shipmentId_example; // {String} 
var opts = {
  'pageSize': 10, // {Integer} 
  'paginationToken': paginationToken_example, // {String} 
  'allPages': 1 // {Integer} Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listShipmentBoxes(inboundPlanId, shipmentId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var shipmentId = shipmentId_example;  // String |  (default to null)
            var pageSize = 10;  // Integer |  (optional)  (default to null)
            var paginationToken = paginationToken_example;  // String |  (optional)  (default to null)
            var allPages = 1;  // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional)  (default to null)

            try {
                listShipmentBoxes_200_response result = apiInstance.listShipmentBoxes(inboundPlanId, shipmentId, pageSize, paginationToken, allPages);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.listShipmentBoxes: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$shipmentId = shipmentId_example; // String | 
$pageSize = 10; // Integer | 
$paginationToken = paginationToken_example; // String | 
$allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

try {
    $result = $api_instance->listShipmentBoxes($inboundPlanId, $shipmentId, $pageSize, $paginationToken, $allPages);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SpApiFbaInboundApi->listShipmentBoxes: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SpApiFbaInboundApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $shipmentId = shipmentId_example; # String | 
my $pageSize = 10; # Integer | 
my $paginationToken = paginationToken_example; # String | 
my $allPages = 1; # Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

eval {
    my $result = $api_instance->listShipmentBoxes(inboundPlanId => $inboundPlanId, shipmentId => $shipmentId, pageSize => $pageSize, paginationToken => $paginationToken, allPages => $allPages);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->listShipmentBoxes: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
shipmentId = shipmentId_example # String |  (default to null)
pageSize = 10 # Integer |  (optional) (default to null)
paginationToken = paginationToken_example # String |  (optional) (default to null)
allPages = 1 # Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional) (default to null)

try:
    api_response = api_instance.list_shipment_boxes(inboundPlanId, shipmentId, pageSize=pageSize, paginationToken=paginationToken, allPages=allPages)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->listShipmentBoxes: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let shipmentId = shipmentId_example; // String
    let pageSize = 10; // Integer
    let paginationToken = paginationToken_example; // String
    let allPages = 1; // Integer

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.listShipmentBoxes(inboundPlanId, shipmentId, pageSize, paginationToken, allPages, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
shipmentId*
String
Required
Query parameters
Name Description
pageSize
Integer
paginationToken
String
allPages
Integer
Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

Responses


listShipmentContentUpdatePreviews

A wrapper around Amazon's [listShipmentContentUpdatePreviews](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#listshipmentcontentupdatepreviews) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/contentUpdatePreviews

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/contentUpdatePreviews?pageSize=10&paginationToken=paginationToken_example&allPages=1"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        Integer pageSize = 10; // Integer | 
        String paginationToken = paginationToken_example; // String | 
        Integer allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

        try {
            listShipmentContentUpdatePreviews_200_response result = apiInstance.listShipmentContentUpdatePreviews(inboundPlanId, shipmentId, pageSize, paginationToken, allPages);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listShipmentContentUpdatePreviews");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String shipmentId = new String(); // String | 
final Integer pageSize = new Integer(); // Integer | 
final String paginationToken = new String(); // String | 
final Integer allPages = new Integer(); // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

try {
    final result = await api_instance.listShipmentContentUpdatePreviews(inboundPlanId, shipmentId, pageSize, paginationToken, allPages);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listShipmentContentUpdatePreviews: $e\n');
}

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        Integer pageSize = 10; // Integer | 
        String paginationToken = paginationToken_example; // String | 
        Integer allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

        try {
            listShipmentContentUpdatePreviews_200_response result = apiInstance.listShipmentContentUpdatePreviews(inboundPlanId, shipmentId, pageSize, paginationToken, allPages);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listShipmentContentUpdatePreviews");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *shipmentId = shipmentId_example; //  (default to null)
Integer *pageSize = 10; //  (optional) (default to null)
String *paginationToken = paginationToken_example; //  (optional) (default to null)
Integer *allPages = 1; // Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional) (default to null)

[apiInstance listShipmentContentUpdatePreviewsWith:inboundPlanId
    shipmentId:shipmentId
    pageSize:pageSize
    paginationToken:paginationToken
    allPages:allPages
              completionHandler: ^(listShipmentContentUpdatePreviews_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var shipmentId = shipmentId_example; // {String} 
var opts = {
  'pageSize': 10, // {Integer} 
  'paginationToken': paginationToken_example, // {String} 
  'allPages': 1 // {Integer} Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listShipmentContentUpdatePreviews(inboundPlanId, shipmentId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var shipmentId = shipmentId_example;  // String |  (default to null)
            var pageSize = 10;  // Integer |  (optional)  (default to null)
            var paginationToken = paginationToken_example;  // String |  (optional)  (default to null)
            var allPages = 1;  // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional)  (default to null)

            try {
                listShipmentContentUpdatePreviews_200_response result = apiInstance.listShipmentContentUpdatePreviews(inboundPlanId, shipmentId, pageSize, paginationToken, allPages);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.listShipmentContentUpdatePreviews: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$shipmentId = shipmentId_example; // String | 
$pageSize = 10; // Integer | 
$paginationToken = paginationToken_example; // String | 
$allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

try {
    $result = $api_instance->listShipmentContentUpdatePreviews($inboundPlanId, $shipmentId, $pageSize, $paginationToken, $allPages);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SpApiFbaInboundApi->listShipmentContentUpdatePreviews: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SpApiFbaInboundApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $shipmentId = shipmentId_example; # String | 
my $pageSize = 10; # Integer | 
my $paginationToken = paginationToken_example; # String | 
my $allPages = 1; # Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

eval {
    my $result = $api_instance->listShipmentContentUpdatePreviews(inboundPlanId => $inboundPlanId, shipmentId => $shipmentId, pageSize => $pageSize, paginationToken => $paginationToken, allPages => $allPages);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->listShipmentContentUpdatePreviews: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
shipmentId = shipmentId_example # String |  (default to null)
pageSize = 10 # Integer |  (optional) (default to null)
paginationToken = paginationToken_example # String |  (optional) (default to null)
allPages = 1 # Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional) (default to null)

try:
    api_response = api_instance.list_shipment_content_update_previews(inboundPlanId, shipmentId, pageSize=pageSize, paginationToken=paginationToken, allPages=allPages)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->listShipmentContentUpdatePreviews: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let shipmentId = shipmentId_example; // String
    let pageSize = 10; // Integer
    let paginationToken = paginationToken_example; // String
    let allPages = 1; // Integer

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.listShipmentContentUpdatePreviews(inboundPlanId, shipmentId, pageSize, paginationToken, allPages, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
shipmentId*
String
Required
Query parameters
Name Description
pageSize
Integer
paginationToken
String
allPages
Integer
Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

Responses

Name Type Format Description
x-request-id String

listShipmentItems

A wrapper around Amazon's [listShipmentItems](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#listshipmentitems) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/items

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/items?pageSize=10&paginationToken=paginationToken_example&allPages=1"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        Integer pageSize = 10; // Integer | 
        String paginationToken = paginationToken_example; // String | 
        Integer allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

        try {
            listShipmentItems_200_response result = apiInstance.listShipmentItems(inboundPlanId, shipmentId, pageSize, paginationToken, allPages);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listShipmentItems");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String shipmentId = new String(); // String | 
final Integer pageSize = new Integer(); // Integer | 
final String paginationToken = new String(); // String | 
final Integer allPages = new Integer(); // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

try {
    final result = await api_instance.listShipmentItems(inboundPlanId, shipmentId, pageSize, paginationToken, allPages);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listShipmentItems: $e\n');
}

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        Integer pageSize = 10; // Integer | 
        String paginationToken = paginationToken_example; // String | 
        Integer allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

        try {
            listShipmentItems_200_response result = apiInstance.listShipmentItems(inboundPlanId, shipmentId, pageSize, paginationToken, allPages);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listShipmentItems");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *shipmentId = shipmentId_example; //  (default to null)
Integer *pageSize = 10; //  (optional) (default to null)
String *paginationToken = paginationToken_example; //  (optional) (default to null)
Integer *allPages = 1; // Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional) (default to null)

[apiInstance listShipmentItemsWith:inboundPlanId
    shipmentId:shipmentId
    pageSize:pageSize
    paginationToken:paginationToken
    allPages:allPages
              completionHandler: ^(listShipmentItems_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var shipmentId = shipmentId_example; // {String} 
var opts = {
  'pageSize': 10, // {Integer} 
  'paginationToken': paginationToken_example, // {String} 
  'allPages': 1 // {Integer} Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listShipmentItems(inboundPlanId, shipmentId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var shipmentId = shipmentId_example;  // String |  (default to null)
            var pageSize = 10;  // Integer |  (optional)  (default to null)
            var paginationToken = paginationToken_example;  // String |  (optional)  (default to null)
            var allPages = 1;  // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional)  (default to null)

            try {
                listShipmentItems_200_response result = apiInstance.listShipmentItems(inboundPlanId, shipmentId, pageSize, paginationToken, allPages);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.listShipmentItems: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$shipmentId = shipmentId_example; // String | 
$pageSize = 10; // Integer | 
$paginationToken = paginationToken_example; // String | 
$allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

try {
    $result = $api_instance->listShipmentItems($inboundPlanId, $shipmentId, $pageSize, $paginationToken, $allPages);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SpApiFbaInboundApi->listShipmentItems: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SpApiFbaInboundApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $shipmentId = shipmentId_example; # String | 
my $pageSize = 10; # Integer | 
my $paginationToken = paginationToken_example; # String | 
my $allPages = 1; # Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

eval {
    my $result = $api_instance->listShipmentItems(inboundPlanId => $inboundPlanId, shipmentId => $shipmentId, pageSize => $pageSize, paginationToken => $paginationToken, allPages => $allPages);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->listShipmentItems: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
shipmentId = shipmentId_example # String |  (default to null)
pageSize = 10 # Integer |  (optional) (default to null)
paginationToken = paginationToken_example # String |  (optional) (default to null)
allPages = 1 # Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional) (default to null)

try:
    api_response = api_instance.list_shipment_items(inboundPlanId, shipmentId, pageSize=pageSize, paginationToken=paginationToken, allPages=allPages)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->listShipmentItems: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let shipmentId = shipmentId_example; // String
    let pageSize = 10; // Integer
    let paginationToken = paginationToken_example; // String
    let allPages = 1; // Integer

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.listShipmentItems(inboundPlanId, shipmentId, pageSize, paginationToken, allPages, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
shipmentId*
String
Required
Query parameters
Name Description
pageSize
Integer
paginationToken
String
allPages
Integer
Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

Responses


listShipmentPallets

A wrapper around Amazon's [listShipmentPallets](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#listshipmentpallets) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/pallets

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/pallets?pageSize=10&paginationToken=paginationToken_example&allPages=1"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        Integer pageSize = 10; // Integer | 
        String paginationToken = paginationToken_example; // String | 
        Integer allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

        try {
            listShipmentPallets_200_response result = apiInstance.listShipmentPallets(inboundPlanId, shipmentId, pageSize, paginationToken, allPages);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listShipmentPallets");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String shipmentId = new String(); // String | 
final Integer pageSize = new Integer(); // Integer | 
final String paginationToken = new String(); // String | 
final Integer allPages = new Integer(); // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

try {
    final result = await api_instance.listShipmentPallets(inboundPlanId, shipmentId, pageSize, paginationToken, allPages);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listShipmentPallets: $e\n');
}

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        Integer pageSize = 10; // Integer | 
        String paginationToken = paginationToken_example; // String | 
        Integer allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

        try {
            listShipmentPallets_200_response result = apiInstance.listShipmentPallets(inboundPlanId, shipmentId, pageSize, paginationToken, allPages);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listShipmentPallets");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *shipmentId = shipmentId_example; //  (default to null)
Integer *pageSize = 10; //  (optional) (default to null)
String *paginationToken = paginationToken_example; //  (optional) (default to null)
Integer *allPages = 1; // Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional) (default to null)

[apiInstance listShipmentPalletsWith:inboundPlanId
    shipmentId:shipmentId
    pageSize:pageSize
    paginationToken:paginationToken
    allPages:allPages
              completionHandler: ^(listShipmentPallets_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var shipmentId = shipmentId_example; // {String} 
var opts = {
  'pageSize': 10, // {Integer} 
  'paginationToken': paginationToken_example, // {String} 
  'allPages': 1 // {Integer} Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listShipmentPallets(inboundPlanId, shipmentId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var shipmentId = shipmentId_example;  // String |  (default to null)
            var pageSize = 10;  // Integer |  (optional)  (default to null)
            var paginationToken = paginationToken_example;  // String |  (optional)  (default to null)
            var allPages = 1;  // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional)  (default to null)

            try {
                listShipmentPallets_200_response result = apiInstance.listShipmentPallets(inboundPlanId, shipmentId, pageSize, paginationToken, allPages);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.listShipmentPallets: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$shipmentId = shipmentId_example; // String | 
$pageSize = 10; // Integer | 
$paginationToken = paginationToken_example; // String | 
$allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

try {
    $result = $api_instance->listShipmentPallets($inboundPlanId, $shipmentId, $pageSize, $paginationToken, $allPages);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SpApiFbaInboundApi->listShipmentPallets: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SpApiFbaInboundApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $shipmentId = shipmentId_example; # String | 
my $pageSize = 10; # Integer | 
my $paginationToken = paginationToken_example; # String | 
my $allPages = 1; # Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

eval {
    my $result = $api_instance->listShipmentPallets(inboundPlanId => $inboundPlanId, shipmentId => $shipmentId, pageSize => $pageSize, paginationToken => $paginationToken, allPages => $allPages);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->listShipmentPallets: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
shipmentId = shipmentId_example # String |  (default to null)
pageSize = 10 # Integer |  (optional) (default to null)
paginationToken = paginationToken_example # String |  (optional) (default to null)
allPages = 1 # Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional) (default to null)

try:
    api_response = api_instance.list_shipment_pallets(inboundPlanId, shipmentId, pageSize=pageSize, paginationToken=paginationToken, allPages=allPages)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->listShipmentPallets: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let shipmentId = shipmentId_example; // String
    let pageSize = 10; // Integer
    let paginationToken = paginationToken_example; // String
    let allPages = 1; // Integer

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.listShipmentPallets(inboundPlanId, shipmentId, pageSize, paginationToken, allPages, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
shipmentId*
String
Required
Query parameters
Name Description
pageSize
Integer
paginationToken
String
allPages
Integer
Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

Responses


listTransportationOptions

A wrapper around Amazon's [listTransportationOptions](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#listtransportationoptions) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/transportationOptions

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/transportationOptions?pageSize=10&paginationToken=paginationToken_example&placementOptionId=placementOptionId_example&shipmentId=shipmentId_example&allPages=1"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        Integer pageSize = 10; // Integer | 
        String paginationToken = paginationToken_example; // String | 
        String placementOptionId = placementOptionId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        Integer allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

        try {
            listTransportationOptions_200_response result = apiInstance.listTransportationOptions(inboundPlanId, pageSize, paginationToken, placementOptionId, shipmentId, allPages);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listTransportationOptions");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final Integer pageSize = new Integer(); // Integer | 
final String paginationToken = new String(); // String | 
final String placementOptionId = new String(); // String | 
final String shipmentId = new String(); // String | 
final Integer allPages = new Integer(); // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

try {
    final result = await api_instance.listTransportationOptions(inboundPlanId, pageSize, paginationToken, placementOptionId, shipmentId, allPages);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listTransportationOptions: $e\n');
}

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        Integer pageSize = 10; // Integer | 
        String paginationToken = paginationToken_example; // String | 
        String placementOptionId = placementOptionId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        Integer allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

        try {
            listTransportationOptions_200_response result = apiInstance.listTransportationOptions(inboundPlanId, pageSize, paginationToken, placementOptionId, shipmentId, allPages);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#listTransportationOptions");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
Integer *pageSize = 10; //  (optional) (default to null)
String *paginationToken = paginationToken_example; //  (optional) (default to null)
String *placementOptionId = placementOptionId_example; //  (optional) (default to null)
String *shipmentId = shipmentId_example; //  (optional) (default to null)
Integer *allPages = 1; // Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional) (default to null)

[apiInstance listTransportationOptionsWith:inboundPlanId
    pageSize:pageSize
    paginationToken:paginationToken
    placementOptionId:placementOptionId
    shipmentId:shipmentId
    allPages:allPages
              completionHandler: ^(listTransportationOptions_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var opts = {
  'pageSize': 10, // {Integer} 
  'paginationToken': paginationToken_example, // {String} 
  'placementOptionId': placementOptionId_example, // {String} 
  'shipmentId': shipmentId_example, // {String} 
  'allPages': 1 // {Integer} Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listTransportationOptions(inboundPlanId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var pageSize = 10;  // Integer |  (optional)  (default to null)
            var paginationToken = paginationToken_example;  // String |  (optional)  (default to null)
            var placementOptionId = placementOptionId_example;  // String |  (optional)  (default to null)
            var shipmentId = shipmentId_example;  // String |  (optional)  (default to null)
            var allPages = 1;  // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional)  (default to null)

            try {
                listTransportationOptions_200_response result = apiInstance.listTransportationOptions(inboundPlanId, pageSize, paginationToken, placementOptionId, shipmentId, allPages);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.listTransportationOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$pageSize = 10; // Integer | 
$paginationToken = paginationToken_example; // String | 
$placementOptionId = placementOptionId_example; // String | 
$shipmentId = shipmentId_example; // String | 
$allPages = 1; // Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

try {
    $result = $api_instance->listTransportationOptions($inboundPlanId, $pageSize, $paginationToken, $placementOptionId, $shipmentId, $allPages);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SpApiFbaInboundApi->listTransportationOptions: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SpApiFbaInboundApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $pageSize = 10; # Integer | 
my $paginationToken = paginationToken_example; # String | 
my $placementOptionId = placementOptionId_example; # String | 
my $shipmentId = shipmentId_example; # String | 
my $allPages = 1; # Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

eval {
    my $result = $api_instance->listTransportationOptions(inboundPlanId => $inboundPlanId, pageSize => $pageSize, paginationToken => $paginationToken, placementOptionId => $placementOptionId, shipmentId => $shipmentId, allPages => $allPages);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->listTransportationOptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
pageSize = 10 # Integer |  (optional) (default to null)
paginationToken = paginationToken_example # String |  (optional) (default to null)
placementOptionId = placementOptionId_example # String |  (optional) (default to null)
shipmentId = shipmentId_example # String |  (optional) (default to null)
allPages = 1 # Integer | Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets. (optional) (default to null)

try:
    api_response = api_instance.list_transportation_options(inboundPlanId, pageSize=pageSize, paginationToken=paginationToken, placementOptionId=placementOptionId, shipmentId=shipmentId, allPages=allPages)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->listTransportationOptions: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let pageSize = 10; // Integer
    let paginationToken = paginationToken_example; // String
    let placementOptionId = placementOptionId_example; // String
    let shipmentId = shipmentId_example; // String
    let allPages = 1; // Integer

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.listTransportationOptions(inboundPlanId, pageSize, paginationToken, placementOptionId, shipmentId, allPages, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
Query parameters
Name Description
pageSize
Integer
paginationToken
String
placementOptionId
String
shipmentId
String
allPages
Integer
Attempt to get all pages by auto-paging server-side. May be slow or timeout for large datasets.

Responses


scheduleSelfShipAppointment

A wrapper around Amazon's [scheduleSelfShipAppointment](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#scheduleselfshipappointment) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/selfShipAppointmentSlots/{slotId}/schedule

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/selfShipAppointmentSlots/{slotId}/schedule" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        String slotId = slotId_example; // String | 
        ScheduleSelfShipAppointmentRequest scheduleSelfShipAppointmentRequest = ; // ScheduleSelfShipAppointmentRequest | 

        try {
            scheduleSelfShipAppointment_200_response result = apiInstance.scheduleSelfShipAppointment(inboundPlanId, shipmentId, slotId, scheduleSelfShipAppointmentRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#scheduleSelfShipAppointment");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String shipmentId = new String(); // String | 
final String slotId = new String(); // String | 
final ScheduleSelfShipAppointmentRequest scheduleSelfShipAppointmentRequest = new ScheduleSelfShipAppointmentRequest(); // ScheduleSelfShipAppointmentRequest | 

try {
    final result = await api_instance.scheduleSelfShipAppointment(inboundPlanId, shipmentId, slotId, scheduleSelfShipAppointmentRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->scheduleSelfShipAppointment: $e\n');
}

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        String slotId = slotId_example; // String | 
        ScheduleSelfShipAppointmentRequest scheduleSelfShipAppointmentRequest = ; // ScheduleSelfShipAppointmentRequest | 

        try {
            scheduleSelfShipAppointment_200_response result = apiInstance.scheduleSelfShipAppointment(inboundPlanId, shipmentId, slotId, scheduleSelfShipAppointmentRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#scheduleSelfShipAppointment");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *shipmentId = shipmentId_example; //  (default to null)
String *slotId = slotId_example; //  (default to null)
ScheduleSelfShipAppointmentRequest *scheduleSelfShipAppointmentRequest = ; //  (optional)

[apiInstance scheduleSelfShipAppointmentWith:inboundPlanId
    shipmentId:shipmentId
    slotId:slotId
    scheduleSelfShipAppointmentRequest:scheduleSelfShipAppointmentRequest
              completionHandler: ^(scheduleSelfShipAppointment_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var shipmentId = shipmentId_example; // {String} 
var slotId = slotId_example; // {String} 
var opts = {
  'scheduleSelfShipAppointmentRequest':  // {ScheduleSelfShipAppointmentRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.scheduleSelfShipAppointment(inboundPlanId, shipmentId, slotId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var shipmentId = shipmentId_example;  // String |  (default to null)
            var slotId = slotId_example;  // String |  (default to null)
            var scheduleSelfShipAppointmentRequest = new ScheduleSelfShipAppointmentRequest(); // ScheduleSelfShipAppointmentRequest |  (optional) 

            try {
                scheduleSelfShipAppointment_200_response result = apiInstance.scheduleSelfShipAppointment(inboundPlanId, shipmentId, slotId, scheduleSelfShipAppointmentRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.scheduleSelfShipAppointment: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$shipmentId = shipmentId_example; // String | 
$slotId = slotId_example; // String | 
$scheduleSelfShipAppointmentRequest = ; // ScheduleSelfShipAppointmentRequest | 

try {
    $result = $api_instance->scheduleSelfShipAppointment($inboundPlanId, $shipmentId, $slotId, $scheduleSelfShipAppointmentRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SpApiFbaInboundApi->scheduleSelfShipAppointment: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SpApiFbaInboundApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $shipmentId = shipmentId_example; # String | 
my $slotId = slotId_example; # String | 
my $scheduleSelfShipAppointmentRequest = WWW::OPenAPIClient::Object::ScheduleSelfShipAppointmentRequest->new(); # ScheduleSelfShipAppointmentRequest | 

eval {
    my $result = $api_instance->scheduleSelfShipAppointment(inboundPlanId => $inboundPlanId, shipmentId => $shipmentId, slotId => $slotId, scheduleSelfShipAppointmentRequest => $scheduleSelfShipAppointmentRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->scheduleSelfShipAppointment: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
shipmentId = shipmentId_example # String |  (default to null)
slotId = slotId_example # String |  (default to null)
scheduleSelfShipAppointmentRequest =  # ScheduleSelfShipAppointmentRequest |  (optional)

try:
    api_response = api_instance.schedule_self_ship_appointment(inboundPlanId, shipmentId, slotId, scheduleSelfShipAppointmentRequest=scheduleSelfShipAppointmentRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->scheduleSelfShipAppointment: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let shipmentId = shipmentId_example; // String
    let slotId = slotId_example; // String
    let scheduleSelfShipAppointmentRequest = ; // ScheduleSelfShipAppointmentRequest

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.scheduleSelfShipAppointment(inboundPlanId, shipmentId, slotId, scheduleSelfShipAppointmentRequest, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
shipmentId*
String
Required
slotId*
String
Required
Body parameters
Name Description
scheduleSelfShipAppointmentRequest

Responses


setPackingInformation

A wrapper around Amazon's [setPackingInformation](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#setpackinginformation) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/packingInformation

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/packingInformation?operationComplete=1" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
        SetPackingInformationRequest setPackingInformationRequest = ; // SetPackingInformationRequest | 

        try {
            setPackingInformation_200_response result = apiInstance.setPackingInformation(inboundPlanId, operationComplete, setPackingInformationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#setPackingInformation");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final Integer operationComplete = new Integer(); // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
final SetPackingInformationRequest setPackingInformationRequest = new SetPackingInformationRequest(); // SetPackingInformationRequest | 

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

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
        SetPackingInformationRequest setPackingInformationRequest = ; // SetPackingInformationRequest | 

        try {
            setPackingInformation_200_response result = apiInstance.setPackingInformation(inboundPlanId, operationComplete, setPackingInformationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#setPackingInformation");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
Integer *operationComplete = 1; // Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)
SetPackingInformationRequest *setPackingInformationRequest = ; //  (optional)

[apiInstance setPackingInformationWith:inboundPlanId
    operationComplete:operationComplete
    setPackingInformationRequest:setPackingInformationRequest
              completionHandler: ^(setPackingInformation_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var opts = {
  'operationComplete': 1, // {Integer} Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
  'setPackingInformationRequest':  // {SetPackingInformationRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.setPackingInformation(inboundPlanId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var operationComplete = 1;  // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional)  (default to null)
            var setPackingInformationRequest = new SetPackingInformationRequest(); // SetPackingInformationRequest |  (optional) 

            try {
                setPackingInformation_200_response result = apiInstance.setPackingInformation(inboundPlanId, operationComplete, setPackingInformationRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.setPackingInformation: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
$setPackingInformationRequest = ; // SetPackingInformationRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $operationComplete = 1; # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
my $setPackingInformationRequest = WWW::OPenAPIClient::Object::SetPackingInformationRequest->new(); # SetPackingInformationRequest | 

eval {
    my $result = $api_instance->setPackingInformation(inboundPlanId => $inboundPlanId, operationComplete => $operationComplete, setPackingInformationRequest => $setPackingInformationRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->setPackingInformation: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
operationComplete = 1 # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)
setPackingInformationRequest =  # SetPackingInformationRequest |  (optional)

try:
    api_response = api_instance.set_packing_information(inboundPlanId, operationComplete=operationComplete, setPackingInformationRequest=setPackingInformationRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->setPackingInformation: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let operationComplete = 1; // Integer
    let setPackingInformationRequest = ; // SetPackingInformationRequest

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.setPackingInformation(inboundPlanId, operationComplete, setPackingInformationRequest, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
Body parameters
Name Description
setPackingInformationRequest

Query parameters
Name Description
operationComplete
Integer
Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

Responses

Name Type Format Description
x-request-id String

setPrepDetails

A wrapper around Amazon's [setPrepDetails](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#setprepdetails) API


/api/az/inbound/fba/items/prepDetails

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/items/prepDetails?operationComplete=1" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
        SetPrepDetailsRequest setPrepDetailsRequest = ; // SetPrepDetailsRequest | 

        try {
            setPrepDetails_200_response result = apiInstance.setPrepDetails(operationComplete, setPrepDetailsRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#setPrepDetails");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer operationComplete = new Integer(); // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
final SetPrepDetailsRequest setPrepDetailsRequest = new SetPrepDetailsRequest(); // SetPrepDetailsRequest | 

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

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
        SetPrepDetailsRequest setPrepDetailsRequest = ; // SetPrepDetailsRequest | 

        try {
            setPrepDetails_200_response result = apiInstance.setPrepDetails(operationComplete, setPrepDetailsRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#setPrepDetails");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
Integer *operationComplete = 1; // Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)
SetPrepDetailsRequest *setPrepDetailsRequest = ; //  (optional)

[apiInstance setPrepDetailsWith:operationComplete
    setPrepDetailsRequest:setPrepDetailsRequest
              completionHandler: ^(setPrepDetails_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var opts = {
  'operationComplete': 1, // {Integer} Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
  'setPrepDetailsRequest':  // {SetPrepDetailsRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.setPrepDetails(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var operationComplete = 1;  // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional)  (default to null)
            var setPrepDetailsRequest = new SetPrepDetailsRequest(); // SetPrepDetailsRequest |  (optional) 

            try {
                setPrepDetails_200_response result = apiInstance.setPrepDetails(operationComplete, setPrepDetailsRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.setPrepDetails: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
$setPrepDetailsRequest = ; // SetPrepDetailsRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $operationComplete = 1; # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
my $setPrepDetailsRequest = WWW::OPenAPIClient::Object::SetPrepDetailsRequest->new(); # SetPrepDetailsRequest | 

eval {
    my $result = $api_instance->setPrepDetails(operationComplete => $operationComplete, setPrepDetailsRequest => $setPrepDetailsRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->setPrepDetails: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
operationComplete = 1 # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)
setPrepDetailsRequest =  # SetPrepDetailsRequest |  (optional)

try:
    api_response = api_instance.set_prep_details(operationComplete=operationComplete, setPrepDetailsRequest=setPrepDetailsRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->setPrepDetails: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let operationComplete = 1; // Integer
    let setPrepDetailsRequest = ; // SetPrepDetailsRequest

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.setPrepDetails(operationComplete, setPrepDetailsRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
setPrepDetailsRequest

Query parameters
Name Description
operationComplete
Integer
Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

Responses


updateInboundPlanName

A wrapper around Amazon's [updateInboundPlanName](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#updateinboundplanname) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/name

Usage and SDK Samples

curl -X PUT \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/name" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        UpdateInboundPlanNameRequest updateInboundPlanNameRequest = ; // UpdateInboundPlanNameRequest | 

        try {
            apiInstance.updateInboundPlanName(inboundPlanId, updateInboundPlanNameRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#updateInboundPlanName");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final UpdateInboundPlanNameRequest updateInboundPlanNameRequest = new UpdateInboundPlanNameRequest(); // UpdateInboundPlanNameRequest | 

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

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        UpdateInboundPlanNameRequest updateInboundPlanNameRequest = ; // UpdateInboundPlanNameRequest | 

        try {
            apiInstance.updateInboundPlanName(inboundPlanId, updateInboundPlanNameRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#updateInboundPlanName");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
UpdateInboundPlanNameRequest *updateInboundPlanNameRequest = ; //  (optional)

[apiInstance updateInboundPlanNameWith:inboundPlanId
    updateInboundPlanNameRequest:updateInboundPlanNameRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var opts = {
  'updateInboundPlanNameRequest':  // {UpdateInboundPlanNameRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateInboundPlanName(inboundPlanId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var updateInboundPlanNameRequest = new UpdateInboundPlanNameRequest(); // UpdateInboundPlanNameRequest |  (optional) 

            try {
                apiInstance.updateInboundPlanName(inboundPlanId, updateInboundPlanNameRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.updateInboundPlanName: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$updateInboundPlanNameRequest = ; // UpdateInboundPlanNameRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $updateInboundPlanNameRequest = WWW::OPenAPIClient::Object::UpdateInboundPlanNameRequest->new(); # UpdateInboundPlanNameRequest | 

eval {
    $api_instance->updateInboundPlanName(inboundPlanId => $inboundPlanId, updateInboundPlanNameRequest => $updateInboundPlanNameRequest);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->updateInboundPlanName: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
updateInboundPlanNameRequest =  # UpdateInboundPlanNameRequest |  (optional)

try:
    api_instance.update_inbound_plan_name(inboundPlanId, updateInboundPlanNameRequest=updateInboundPlanNameRequest)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->updateInboundPlanName: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let updateInboundPlanNameRequest = ; // UpdateInboundPlanNameRequest

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.updateInboundPlanName(inboundPlanId, updateInboundPlanNameRequest, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
Body parameters
Name Description
updateInboundPlanNameRequest

Responses


updateItemComplianceDetails

A wrapper around Amazon's [updateItemComplianceDetails](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#updateitemcompliancedetails) API


/api/az/inbound/fba/items/compliance

Usage and SDK Samples

curl -X PUT \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/items/compliance?operationComplete=1" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
        UpdateItemComplianceDetailsRequest updateItemComplianceDetailsRequest = ; // UpdateItemComplianceDetailsRequest | 

        try {
            updateItemComplianceDetails_200_response result = apiInstance.updateItemComplianceDetails(operationComplete, updateItemComplianceDetailsRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#updateItemComplianceDetails");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer operationComplete = new Integer(); // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
final UpdateItemComplianceDetailsRequest updateItemComplianceDetailsRequest = new UpdateItemComplianceDetailsRequest(); // UpdateItemComplianceDetailsRequest | 

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

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
        UpdateItemComplianceDetailsRequest updateItemComplianceDetailsRequest = ; // UpdateItemComplianceDetailsRequest | 

        try {
            updateItemComplianceDetails_200_response result = apiInstance.updateItemComplianceDetails(operationComplete, updateItemComplianceDetailsRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#updateItemComplianceDetails");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
Integer *operationComplete = 1; // Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)
UpdateItemComplianceDetailsRequest *updateItemComplianceDetailsRequest = ; //  (optional)

[apiInstance updateItemComplianceDetailsWith:operationComplete
    updateItemComplianceDetailsRequest:updateItemComplianceDetailsRequest
              completionHandler: ^(updateItemComplianceDetails_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var opts = {
  'operationComplete': 1, // {Integer} Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
  'updateItemComplianceDetailsRequest':  // {UpdateItemComplianceDetailsRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateItemComplianceDetails(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var operationComplete = 1;  // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional)  (default to null)
            var updateItemComplianceDetailsRequest = new UpdateItemComplianceDetailsRequest(); // UpdateItemComplianceDetailsRequest |  (optional) 

            try {
                updateItemComplianceDetails_200_response result = apiInstance.updateItemComplianceDetails(operationComplete, updateItemComplianceDetailsRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.updateItemComplianceDetails: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
$updateItemComplianceDetailsRequest = ; // UpdateItemComplianceDetailsRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $operationComplete = 1; # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
my $updateItemComplianceDetailsRequest = WWW::OPenAPIClient::Object::UpdateItemComplianceDetailsRequest->new(); # UpdateItemComplianceDetailsRequest | 

eval {
    my $result = $api_instance->updateItemComplianceDetails(operationComplete => $operationComplete, updateItemComplianceDetailsRequest => $updateItemComplianceDetailsRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->updateItemComplianceDetails: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
operationComplete = 1 # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)
updateItemComplianceDetailsRequest =  # UpdateItemComplianceDetailsRequest |  (optional)

try:
    api_response = api_instance.update_item_compliance_details(operationComplete=operationComplete, updateItemComplianceDetailsRequest=updateItemComplianceDetailsRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->updateItemComplianceDetails: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let operationComplete = 1; // Integer
    let updateItemComplianceDetailsRequest = ; // UpdateItemComplianceDetailsRequest

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.updateItemComplianceDetails(operationComplete, updateItemComplianceDetailsRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
updateItemComplianceDetailsRequest

Query parameters
Name Description
operationComplete
Integer
Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

Responses

Name Type Format Description
x-request-id String

updateShipmentName

A wrapper around Amazon's [updateShipmentName](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#updateshipmentname) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/name

Usage and SDK Samples

curl -X PUT \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/name" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        UpdateShipmentNameRequest updateShipmentNameRequest = ; // UpdateShipmentNameRequest | 

        try {
            apiInstance.updateShipmentName(inboundPlanId, shipmentId, updateShipmentNameRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#updateShipmentName");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String shipmentId = new String(); // String | 
final UpdateShipmentNameRequest updateShipmentNameRequest = new UpdateShipmentNameRequest(); // UpdateShipmentNameRequest | 

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

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        UpdateShipmentNameRequest updateShipmentNameRequest = ; // UpdateShipmentNameRequest | 

        try {
            apiInstance.updateShipmentName(inboundPlanId, shipmentId, updateShipmentNameRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#updateShipmentName");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *shipmentId = shipmentId_example; //  (default to null)
UpdateShipmentNameRequest *updateShipmentNameRequest = ; //  (optional)

[apiInstance updateShipmentNameWith:inboundPlanId
    shipmentId:shipmentId
    updateShipmentNameRequest:updateShipmentNameRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var shipmentId = shipmentId_example; // {String} 
var opts = {
  'updateShipmentNameRequest':  // {UpdateShipmentNameRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateShipmentName(inboundPlanId, shipmentId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var shipmentId = shipmentId_example;  // String |  (default to null)
            var updateShipmentNameRequest = new UpdateShipmentNameRequest(); // UpdateShipmentNameRequest |  (optional) 

            try {
                apiInstance.updateShipmentName(inboundPlanId, shipmentId, updateShipmentNameRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.updateShipmentName: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$shipmentId = shipmentId_example; // String | 
$updateShipmentNameRequest = ; // UpdateShipmentNameRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $shipmentId = shipmentId_example; # String | 
my $updateShipmentNameRequest = WWW::OPenAPIClient::Object::UpdateShipmentNameRequest->new(); # UpdateShipmentNameRequest | 

eval {
    $api_instance->updateShipmentName(inboundPlanId => $inboundPlanId, shipmentId => $shipmentId, updateShipmentNameRequest => $updateShipmentNameRequest);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->updateShipmentName: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
shipmentId = shipmentId_example # String |  (default to null)
updateShipmentNameRequest =  # UpdateShipmentNameRequest |  (optional)

try:
    api_instance.update_shipment_name(inboundPlanId, shipmentId, updateShipmentNameRequest=updateShipmentNameRequest)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->updateShipmentName: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let shipmentId = shipmentId_example; // String
    let updateShipmentNameRequest = ; // UpdateShipmentNameRequest

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.updateShipmentName(inboundPlanId, shipmentId, updateShipmentNameRequest, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
shipmentId*
String
Required
Body parameters
Name Description
updateShipmentNameRequest

Responses


updateShipmentSourceAddress

A wrapper around Amazon's [updateShipmentSourceAddress](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#updateshipmentsourceaddress) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/sourceAddress

Usage and SDK Samples

curl -X PUT \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/sourceAddress?operationComplete=1" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
        UpdateShipmentSourceAddressRequest updateShipmentSourceAddressRequest = ; // UpdateShipmentSourceAddressRequest | 

        try {
            updateShipmentSourceAddress_200_response result = apiInstance.updateShipmentSourceAddress(inboundPlanId, shipmentId, operationComplete, updateShipmentSourceAddressRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#updateShipmentSourceAddress");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String shipmentId = new String(); // String | 
final Integer operationComplete = new Integer(); // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
final UpdateShipmentSourceAddressRequest updateShipmentSourceAddressRequest = new UpdateShipmentSourceAddressRequest(); // UpdateShipmentSourceAddressRequest | 

try {
    final result = await api_instance.updateShipmentSourceAddress(inboundPlanId, shipmentId, operationComplete, updateShipmentSourceAddressRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateShipmentSourceAddress: $e\n');
}

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
        UpdateShipmentSourceAddressRequest updateShipmentSourceAddressRequest = ; // UpdateShipmentSourceAddressRequest | 

        try {
            updateShipmentSourceAddress_200_response result = apiInstance.updateShipmentSourceAddress(inboundPlanId, shipmentId, operationComplete, updateShipmentSourceAddressRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#updateShipmentSourceAddress");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *shipmentId = shipmentId_example; //  (default to null)
Integer *operationComplete = 1; // Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)
UpdateShipmentSourceAddressRequest *updateShipmentSourceAddressRequest = ; //  (optional)

[apiInstance updateShipmentSourceAddressWith:inboundPlanId
    shipmentId:shipmentId
    operationComplete:operationComplete
    updateShipmentSourceAddressRequest:updateShipmentSourceAddressRequest
              completionHandler: ^(updateShipmentSourceAddress_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var shipmentId = shipmentId_example; // {String} 
var opts = {
  'operationComplete': 1, // {Integer} Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
  'updateShipmentSourceAddressRequest':  // {UpdateShipmentSourceAddressRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateShipmentSourceAddress(inboundPlanId, shipmentId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var shipmentId = shipmentId_example;  // String |  (default to null)
            var operationComplete = 1;  // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional)  (default to null)
            var updateShipmentSourceAddressRequest = new UpdateShipmentSourceAddressRequest(); // UpdateShipmentSourceAddressRequest |  (optional) 

            try {
                updateShipmentSourceAddress_200_response result = apiInstance.updateShipmentSourceAddress(inboundPlanId, shipmentId, operationComplete, updateShipmentSourceAddressRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.updateShipmentSourceAddress: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$shipmentId = shipmentId_example; // String | 
$operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
$updateShipmentSourceAddressRequest = ; // UpdateShipmentSourceAddressRequest | 

try {
    $result = $api_instance->updateShipmentSourceAddress($inboundPlanId, $shipmentId, $operationComplete, $updateShipmentSourceAddressRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SpApiFbaInboundApi->updateShipmentSourceAddress: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SpApiFbaInboundApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $shipmentId = shipmentId_example; # String | 
my $operationComplete = 1; # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
my $updateShipmentSourceAddressRequest = WWW::OPenAPIClient::Object::UpdateShipmentSourceAddressRequest->new(); # UpdateShipmentSourceAddressRequest | 

eval {
    my $result = $api_instance->updateShipmentSourceAddress(inboundPlanId => $inboundPlanId, shipmentId => $shipmentId, operationComplete => $operationComplete, updateShipmentSourceAddressRequest => $updateShipmentSourceAddressRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->updateShipmentSourceAddress: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
shipmentId = shipmentId_example # String |  (default to null)
operationComplete = 1 # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)
updateShipmentSourceAddressRequest =  # UpdateShipmentSourceAddressRequest |  (optional)

try:
    api_response = api_instance.update_shipment_source_address(inboundPlanId, shipmentId, operationComplete=operationComplete, updateShipmentSourceAddressRequest=updateShipmentSourceAddressRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->updateShipmentSourceAddress: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let shipmentId = shipmentId_example; // String
    let operationComplete = 1; // Integer
    let updateShipmentSourceAddressRequest = ; // UpdateShipmentSourceAddressRequest

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.updateShipmentSourceAddress(inboundPlanId, shipmentId, operationComplete, updateShipmentSourceAddressRequest, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
shipmentId*
String
Required
Body parameters
Name Description
updateShipmentSourceAddressRequest

Query parameters
Name Description
operationComplete
Integer
Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

Responses

Name Type Format Description
x-request-id String

updateShipmentTrackingDetails

A wrapper around Amazon's [updateShipmentTrackingDetails](https://developer-docs.amazon.com/sp-api/docs/fulfillment-inbound-api-v2024-03-20-reference#updateshipmenttrackingdetails) API


/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/trackingDetails

Usage and SDK Samples

curl -X PUT \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/az/inbound/fba/inboundPlans/{inboundPlanId}/shipments/{shipmentId}/trackingDetails?operationComplete=1" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SpApiFbaInboundApi;

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

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

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

        // Create an instance of the API class
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
        UpdateShipmentTrackingDetailsRequest updateShipmentTrackingDetailsRequest = ; // UpdateShipmentTrackingDetailsRequest | 

        try {
            updateShipmentTrackingDetails_200_response result = apiInstance.updateShipmentTrackingDetails(inboundPlanId, shipmentId, operationComplete, updateShipmentTrackingDetailsRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#updateShipmentTrackingDetails");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String shipmentId = new String(); // String | 
final Integer operationComplete = new Integer(); // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
final UpdateShipmentTrackingDetailsRequest updateShipmentTrackingDetailsRequest = new UpdateShipmentTrackingDetailsRequest(); // UpdateShipmentTrackingDetailsRequest | 

try {
    final result = await api_instance.updateShipmentTrackingDetails(inboundPlanId, shipmentId, operationComplete, updateShipmentTrackingDetailsRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateShipmentTrackingDetails: $e\n');
}

import org.openapitools.client.api.SpApiFbaInboundApi;

public class SpApiFbaInboundApiExample {
    public static void main(String[] args) {
        SpApiFbaInboundApi apiInstance = new SpApiFbaInboundApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        Integer operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
        UpdateShipmentTrackingDetailsRequest updateShipmentTrackingDetailsRequest = ; // UpdateShipmentTrackingDetailsRequest | 

        try {
            updateShipmentTrackingDetails_200_response result = apiInstance.updateShipmentTrackingDetails(inboundPlanId, shipmentId, operationComplete, updateShipmentTrackingDetailsRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SpApiFbaInboundApi#updateShipmentTrackingDetails");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
SpApiFbaInboundApi *apiInstance = [[SpApiFbaInboundApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *shipmentId = shipmentId_example; //  (default to null)
Integer *operationComplete = 1; // Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)
UpdateShipmentTrackingDetailsRequest *updateShipmentTrackingDetailsRequest = ; //  (optional)

[apiInstance updateShipmentTrackingDetailsWith:inboundPlanId
    shipmentId:shipmentId
    operationComplete:operationComplete
    updateShipmentTrackingDetailsRequest:updateShipmentTrackingDetailsRequest
              completionHandler: ^(updateShipmentTrackingDetails_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.SpApiFbaInboundApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var shipmentId = shipmentId_example; // {String} 
var opts = {
  'operationComplete': 1, // {Integer} Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
  'updateShipmentTrackingDetailsRequest':  // {UpdateShipmentTrackingDetailsRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateShipmentTrackingDetails(inboundPlanId, shipmentId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SpApiFbaInboundApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var shipmentId = shipmentId_example;  // String |  (default to null)
            var operationComplete = 1;  // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional)  (default to null)
            var updateShipmentTrackingDetailsRequest = new UpdateShipmentTrackingDetailsRequest(); // UpdateShipmentTrackingDetailsRequest |  (optional) 

            try {
                updateShipmentTrackingDetails_200_response result = apiInstance.updateShipmentTrackingDetails(inboundPlanId, shipmentId, operationComplete, updateShipmentTrackingDetailsRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SpApiFbaInboundApi.updateShipmentTrackingDetails: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SpApiFbaInboundApi();
$inboundPlanId = inboundPlanId_example; // String | 
$shipmentId = shipmentId_example; // String | 
$operationComplete = 1; // Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
$updateShipmentTrackingDetailsRequest = ; // UpdateShipmentTrackingDetailsRequest | 

try {
    $result = $api_instance->updateShipmentTrackingDetails($inboundPlanId, $shipmentId, $operationComplete, $updateShipmentTrackingDetailsRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SpApiFbaInboundApi->updateShipmentTrackingDetails: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SpApiFbaInboundApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SpApiFbaInboundApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $shipmentId = shipmentId_example; # String | 
my $operationComplete = 1; # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.
my $updateShipmentTrackingDetailsRequest = WWW::OPenAPIClient::Object::UpdateShipmentTrackingDetailsRequest->new(); # UpdateShipmentTrackingDetailsRequest | 

eval {
    my $result = $api_instance->updateShipmentTrackingDetails(inboundPlanId => $inboundPlanId, shipmentId => $shipmentId, operationComplete => $operationComplete, updateShipmentTrackingDetailsRequest => $updateShipmentTrackingDetailsRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SpApiFbaInboundApi->updateShipmentTrackingDetails: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.SpApiFbaInboundApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
shipmentId = shipmentId_example # String |  (default to null)
operationComplete = 1 # Integer | Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`. (optional) (default to null)
updateShipmentTrackingDetailsRequest =  # UpdateShipmentTrackingDetailsRequest |  (optional)

try:
    api_response = api_instance.update_shipment_tracking_details(inboundPlanId, shipmentId, operationComplete=operationComplete, updateShipmentTrackingDetailsRequest=updateShipmentTrackingDetailsRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SpApiFbaInboundApi->updateShipmentTrackingDetails: %s\n" % e)
extern crate SpApiFbaInboundApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let shipmentId = shipmentId_example; // String
    let operationComplete = 1; // Integer
    let updateShipmentTrackingDetailsRequest = ; // UpdateShipmentTrackingDetailsRequest

    let mut context = SpApiFbaInboundApi::Context::default();
    let result = client.updateShipmentTrackingDetails(inboundPlanId, shipmentId, operationComplete, updateShipmentTrackingDetailsRequest, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inboundPlanId*
String
Required
shipmentId*
String
Required
Body parameters
Name Description
updateShipmentTrackingDetailsRequest

Query parameters
Name Description
operationComplete
Integer
Repeatedly poll `getInboundOperationStatus` on the returned `operationId` until the operation finishes and return the results of that instead of just the `operationId`.

Responses

Name Type Format Description
x-request-id String

V1

createBuylist

Create buylist items


/scout/buylist

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/x-www-form-urlencoded" \
 "https://unity.scanpower.com/scout/buylist"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V1Api;

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

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

        // Create an instance of the API class
        V1Api apiInstance = new V1Api();
        String items = items_example; // String | ```json
[
  {
    "asin": "the asin, required",
    "msku": "the msku, will save as inventory._id, if the record already exists in inventory",
    "import-msku": "save the msku in the misc column, will be used when the item is listed",
    "purchased": "the date you purchased this item",
    "condition": "the item condition, eg. 'NewItem', 'UsedAcceptable', etc",
    "cost": cost in cents (eg 599 = $5.99),
    "source": "the source",
    "expires": "date item expires",
    "notifyme": number of days before expiration to notify me,
    "quantity": number of items purchased,
    // the following fields will be stored in misc
    "stocked-variations",
    "variations",
    "tax-code._id",
    "tax-percentage",
    "notes",
    "discount",
    "originalCost",
    "labor-cost",
    "inbound-shipping-cost"
  }
]
```

        try {
            Object result = apiInstance.createBuylist(items);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V1Api#createBuylist");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String items = new String(); // String | ```json
[
  {
    "asin": "the asin, required",
    "msku": "the msku, will save as inventory._id, if the record already exists in inventory",
    "import-msku": "save the msku in the misc column, will be used when the item is listed",
    "purchased": "the date you purchased this item",
    "condition": "the item condition, eg. 'NewItem', 'UsedAcceptable', etc",
    "cost": cost in cents (eg 599 = $5.99),
    "source": "the source",
    "expires": "date item expires",
    "notifyme": number of days before expiration to notify me,
    "quantity": number of items purchased,
    // the following fields will be stored in misc
    "stocked-variations",
    "variations",
    "tax-code._id",
    "tax-percentage",
    "notes",
    "discount",
    "originalCost",
    "labor-cost",
    "inbound-shipping-cost"
  }
]
```

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

import org.openapitools.client.api.V1Api;

public class V1ApiExample {
    public static void main(String[] args) {
        V1Api apiInstance = new V1Api();
        String items = items_example; // String | ```json
[
  {
    "asin": "the asin, required",
    "msku": "the msku, will save as inventory._id, if the record already exists in inventory",
    "import-msku": "save the msku in the misc column, will be used when the item is listed",
    "purchased": "the date you purchased this item",
    "condition": "the item condition, eg. 'NewItem', 'UsedAcceptable', etc",
    "cost": cost in cents (eg 599 = $5.99),
    "source": "the source",
    "expires": "date item expires",
    "notifyme": number of days before expiration to notify me,
    "quantity": number of items purchased,
    // the following fields will be stored in misc
    "stocked-variations",
    "variations",
    "tax-code._id",
    "tax-percentage",
    "notes",
    "discount",
    "originalCost",
    "labor-cost",
    "inbound-shipping-cost"
  }
]
```

        try {
            Object result = apiInstance.createBuylist(items);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V1Api#createBuylist");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic_auth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
V1Api *apiInstance = [[V1Api alloc] init];
String *items = items_example; // ```json
[
  {
    "asin": "the asin, required",
    "msku": "the msku, will save as inventory._id, if the record already exists in inventory",
    "import-msku": "save the msku in the misc column, will be used when the item is listed",
    "purchased": "the date you purchased this item",
    "condition": "the item condition, eg. 'NewItem', 'UsedAcceptable', etc",
    "cost": cost in cents (eg 599 = $5.99),
    "source": "the source",
    "expires": "date item expires",
    "notifyme": number of days before expiration to notify me,
    "quantity": number of items purchased,
    // the following fields will be stored in misc
    "stocked-variations",
    "variations",
    "tax-code._id",
    "tax-percentage",
    "notes",
    "discount",
    "originalCost",
    "labor-cost",
    "inbound-shipping-cost"
  }
]
``` (optional) (default to null)

[apiInstance createBuylistWith:items
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.V1Api()
var opts = {
  'items': items_example // {String} ```json
[
  {
    "asin": "the asin, required",
    "msku": "the msku, will save as inventory._id, if the record already exists in inventory",
    "import-msku": "save the msku in the misc column, will be used when the item is listed",
    "purchased": "the date you purchased this item",
    "condition": "the item condition, eg. 'NewItem', 'UsedAcceptable', etc",
    "cost": cost in cents (eg 599 = $5.99),
    "source": "the source",
    "expires": "date item expires",
    "notifyme": number of days before expiration to notify me,
    "quantity": number of items purchased,
    // the following fields will be stored in misc
    "stocked-variations",
    "variations",
    "tax-code._id",
    "tax-percentage",
    "notes",
    "discount",
    "originalCost",
    "labor-cost",
    "inbound-shipping-cost"
  }
]
```
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createBuylist(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new V1Api();
            var items = items_example;  // String | ```json
[
  {
    "asin": "the asin, required",
    "msku": "the msku, will save as inventory._id, if the record already exists in inventory",
    "import-msku": "save the msku in the misc column, will be used when the item is listed",
    "purchased": "the date you purchased this item",
    "condition": "the item condition, eg. 'NewItem', 'UsedAcceptable', etc",
    "cost": cost in cents (eg 599 = $5.99),
    "source": "the source",
    "expires": "date item expires",
    "notifyme": number of days before expiration to notify me,
    "quantity": number of items purchased,
    // the following fields will be stored in misc
    "stocked-variations",
    "variations",
    "tax-code._id",
    "tax-percentage",
    "notes",
    "discount",
    "originalCost",
    "labor-cost",
    "inbound-shipping-cost"
  }
]
``` (optional)  (default to null)

            try {
                Object result = apiInstance.createBuylist(items);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V1Api.createBuylist: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basic_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V1Api();
$items = items_example; // String | ```json
[
  {
    "asin": "the asin, required",
    "msku": "the msku, will save as inventory._id, if the record already exists in inventory",
    "import-msku": "save the msku in the misc column, will be used when the item is listed",
    "purchased": "the date you purchased this item",
    "condition": "the item condition, eg. 'NewItem', 'UsedAcceptable', etc",
    "cost": cost in cents (eg 599 = $5.99),
    "source": "the source",
    "expires": "date item expires",
    "notifyme": number of days before expiration to notify me,
    "quantity": number of items purchased,
    // the following fields will be stored in misc
    "stocked-variations",
    "variations",
    "tax-code._id",
    "tax-percentage",
    "notes",
    "discount",
    "originalCost",
    "labor-cost",
    "inbound-shipping-cost"
  }
]
```

try {
    $result = $api_instance->createBuylist($items);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V1Api->createBuylist: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V1Api;
# Configure HTTP basic authorization: basic_auth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V1Api->new();
my $items = items_example; # String | ```json
[
  {
    "asin": "the asin, required",
    "msku": "the msku, will save as inventory._id, if the record already exists in inventory",
    "import-msku": "save the msku in the misc column, will be used when the item is listed",
    "purchased": "the date you purchased this item",
    "condition": "the item condition, eg. 'NewItem', 'UsedAcceptable', etc",
    "cost": cost in cents (eg 599 = $5.99),
    "source": "the source",
    "expires": "date item expires",
    "notifyme": number of days before expiration to notify me,
    "quantity": number of items purchased,
    // the following fields will be stored in misc
    "stocked-variations",
    "variations",
    "tax-code._id",
    "tax-percentage",
    "notes",
    "discount",
    "originalCost",
    "labor-cost",
    "inbound-shipping-cost"
  }
]
```

eval {
    my $result = $api_instance->createBuylist(items => $items);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V1Api->createBuylist: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: basic_auth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.V1Api()
items = items_example # String | ```json
[
  {
    "asin": "the asin, required",
    "msku": "the msku, will save as inventory._id, if the record already exists in inventory",
    "import-msku": "save the msku in the misc column, will be used when the item is listed",
    "purchased": "the date you purchased this item",
    "condition": "the item condition, eg. 'NewItem', 'UsedAcceptable', etc",
    "cost": cost in cents (eg 599 = $5.99),
    "source": "the source",
    "expires": "date item expires",
    "notifyme": number of days before expiration to notify me,
    "quantity": number of items purchased,
    // the following fields will be stored in misc
    "stocked-variations",
    "variations",
    "tax-code._id",
    "tax-percentage",
    "notes",
    "discount",
    "originalCost",
    "labor-cost",
    "inbound-shipping-cost"
  }
]
``` (optional) (default to null)

try:
    api_response = api_instance.create_buylist(items=items)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V1Api->createBuylist: %s\n" % e)
extern crate V1Api;

pub fn main() {
    let items = items_example; // String

    let mut context = V1Api::Context::default();
    let result = client.createBuylist(items, &context).wait();

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

Scopes

Parameters

Form parameters
Name Description
items
String (json)
```json [ { "asin": "the asin, required", "msku": "the msku, will save as inventory._id, if the record already exists in inventory", "import-msku": "save the msku in the misc column, will be used when the item is listed", "purchased": "the date you purchased this item", "condition": "the item condition, eg. 'NewItem', 'UsedAcceptable', etc", "cost": cost in cents (eg 599 = $5.99), "source": "the source", "expires": "date item expires", "notifyme": number of days before expiration to notify me, "quantity": number of items purchased, // the following fields will be stored in misc "stocked-variations", "variations", "tax-code._id", "tax-percentage", "notes", "discount", "originalCost", "labor-cost", "inbound-shipping-cost" } ] ```

Responses


getPackHistory


/list/pack-history

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/list/pack-history?start=2025-01-01&end=2025-02-01&created-by=2f16c5b2-97d3-4238-8b89-22851363bf27&shipment=FBA18V17NFFD"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V1Api;

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

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

        // Create an instance of the API class
        V1Api apiInstance = new V1Api();
        String xRequestedWith = XMLHttpRequest; // String | Must be `XMLHttpRequest`
        String start = 2025-01-01; // String | Get items packed after this timestamp
        String end = 2025-02-01; // String | Get items packed before this timestamp
        String createdBy = 2f16c5b2-97d3-4238-8b89-22851363bf27; // String | Optional comma-separated list of user ids to restrict to
        String shipment = FBA18V17NFFD; // String | Optional comma-separated list of shipment ids to restrict to

        try {
            array[getPackHistory_200_response_inner] result = apiInstance.getPackHistory(xRequestedWith, start, end, createdBy, shipment);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V1Api#getPackHistory");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String xRequestedWith = new String(); // String | Must be `XMLHttpRequest`
final String start = new String(); // String | Get items packed after this timestamp
final String end = new String(); // String | Get items packed before this timestamp
final String createdBy = new String(); // String | Optional comma-separated list of user ids to restrict to
final String shipment = new String(); // String | Optional comma-separated list of shipment ids to restrict to

try {
    final result = await api_instance.getPackHistory(xRequestedWith, start, end, createdBy, shipment);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getPackHistory: $e\n');
}

import org.openapitools.client.api.V1Api;

public class V1ApiExample {
    public static void main(String[] args) {
        V1Api apiInstance = new V1Api();
        String xRequestedWith = XMLHttpRequest; // String | Must be `XMLHttpRequest`
        String start = 2025-01-01; // String | Get items packed after this timestamp
        String end = 2025-02-01; // String | Get items packed before this timestamp
        String createdBy = 2f16c5b2-97d3-4238-8b89-22851363bf27; // String | Optional comma-separated list of user ids to restrict to
        String shipment = FBA18V17NFFD; // String | Optional comma-separated list of shipment ids to restrict to

        try {
            array[getPackHistory_200_response_inner] result = apiInstance.getPackHistory(xRequestedWith, start, end, createdBy, shipment);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V1Api#getPackHistory");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic_auth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
V1Api *apiInstance = [[V1Api alloc] init];
String *xRequestedWith = XMLHttpRequest; // Must be `XMLHttpRequest` (default to null)
String *start = 2025-01-01; // Get items packed after this timestamp (optional) (default to null)
String *end = 2025-02-01; // Get items packed before this timestamp (optional) (default to null)
String *createdBy = 2f16c5b2-97d3-4238-8b89-22851363bf27; // Optional comma-separated list of user ids to restrict to (optional) (default to null)
String *shipment = FBA18V17NFFD; // Optional comma-separated list of shipment ids to restrict to (optional) (default to null)

[apiInstance getPackHistoryWith:xRequestedWith
    start:start
    end:end
    createdBy:createdBy
    shipment:shipment
              completionHandler: ^(array[getPackHistory_200_response_inner] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.V1Api()
var xRequestedWith = XMLHttpRequest; // {String} Must be `XMLHttpRequest`
var opts = {
  'start': 2025-01-01, // {String} Get items packed after this timestamp
  'end': 2025-02-01, // {String} Get items packed before this timestamp
  'createdBy': 2f16c5b2-97d3-4238-8b89-22851363bf27, // {String} Optional comma-separated list of user ids to restrict to
  'shipment': FBA18V17NFFD // {String} Optional comma-separated list of shipment ids to restrict to
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getPackHistory(xRequestedWith, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new V1Api();
            var xRequestedWith = XMLHttpRequest;  // String | Must be `XMLHttpRequest` (default to null)
            var start = 2025-01-01;  // String | Get items packed after this timestamp (optional)  (default to null)
            var end = 2025-02-01;  // String | Get items packed before this timestamp (optional)  (default to null)
            var createdBy = 2f16c5b2-97d3-4238-8b89-22851363bf27;  // String | Optional comma-separated list of user ids to restrict to (optional)  (default to null)
            var shipment = FBA18V17NFFD;  // String | Optional comma-separated list of shipment ids to restrict to (optional)  (default to null)

            try {
                array[getPackHistory_200_response_inner] result = apiInstance.getPackHistory(xRequestedWith, start, end, createdBy, shipment);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V1Api.getPackHistory: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basic_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V1Api();
$xRequestedWith = XMLHttpRequest; // String | Must be `XMLHttpRequest`
$start = 2025-01-01; // String | Get items packed after this timestamp
$end = 2025-02-01; // String | Get items packed before this timestamp
$createdBy = 2f16c5b2-97d3-4238-8b89-22851363bf27; // String | Optional comma-separated list of user ids to restrict to
$shipment = FBA18V17NFFD; // String | Optional comma-separated list of shipment ids to restrict to

try {
    $result = $api_instance->getPackHistory($xRequestedWith, $start, $end, $createdBy, $shipment);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V1Api->getPackHistory: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V1Api;
# Configure HTTP basic authorization: basic_auth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V1Api->new();
my $xRequestedWith = XMLHttpRequest; # String | Must be `XMLHttpRequest`
my $start = 2025-01-01; # String | Get items packed after this timestamp
my $end = 2025-02-01; # String | Get items packed before this timestamp
my $createdBy = 2f16c5b2-97d3-4238-8b89-22851363bf27; # String | Optional comma-separated list of user ids to restrict to
my $shipment = FBA18V17NFFD; # String | Optional comma-separated list of shipment ids to restrict to

eval {
    my $result = $api_instance->getPackHistory(xRequestedWith => $xRequestedWith, start => $start, end => $end, createdBy => $createdBy, shipment => $shipment);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V1Api->getPackHistory: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: basic_auth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.V1Api()
xRequestedWith = XMLHttpRequest # String | Must be `XMLHttpRequest` (default to null)
start = 2025-01-01 # String | Get items packed after this timestamp (optional) (default to null)
end = 2025-02-01 # String | Get items packed before this timestamp (optional) (default to null)
createdBy = 2f16c5b2-97d3-4238-8b89-22851363bf27 # String | Optional comma-separated list of user ids to restrict to (optional) (default to null)
shipment = FBA18V17NFFD # String | Optional comma-separated list of shipment ids to restrict to (optional) (default to null)

try:
    api_response = api_instance.get_pack_history(xRequestedWith, start=start, end=end, createdBy=createdBy, shipment=shipment)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V1Api->getPackHistory: %s\n" % e)
extern crate V1Api;

pub fn main() {
    let xRequestedWith = XMLHttpRequest; // String
    let start = 2025-01-01; // String
    let end = 2025-02-01; // String
    let createdBy = 2f16c5b2-97d3-4238-8b89-22851363bf27; // String
    let shipment = FBA18V17NFFD; // String

    let mut context = V1Api::Context::default();
    let result = client.getPackHistory(xRequestedWith, start, end, createdBy, shipment, &context).wait();

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

Scopes

Parameters

Header parameters
Name Description
X-Requested-With*
String
Must be `XMLHttpRequest`
Required
Query parameters
Name Description
start
String
Get items packed after this timestamp
end
String
Get items packed before this timestamp
created-by
String
Optional comma-separated list of user ids to restrict to
shipment
String
Optional comma-separated list of shipment ids to restrict to

Responses


getProxyUsers


/account/?proxy

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/account/?proxy"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V1Api;

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

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

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

        try {
            array[getProxyUsers_200_response_inner] result = apiInstance.getProxyUsers();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V1Api#getProxyUsers");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.V1Api;

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

        try {
            array[getProxyUsers_200_response_inner] result = apiInstance.getProxyUsers();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V1Api#getProxyUsers");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basic_auth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

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

[apiInstance getProxyUsersWithCompletionHandler: 
              ^(array[getProxyUsers_200_response_inner] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.V1Api()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getProxyUsers(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                array[getProxyUsers_200_response_inner] result = apiInstance.getProxyUsers();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V1Api.getProxyUsers: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basic_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

try {
    $result = $api_instance->getProxyUsers();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V1Api->getProxyUsers: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V1Api;
# Configure HTTP basic authorization: basic_auth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

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

eval {
    my $result = $api_instance->getProxyUsers();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V1Api->getProxyUsers: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: basic_auth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.V1Api()

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

pub fn main() {

    let mut context = V1Api::Context::default();
    let result = client.getProxyUsers(&context).wait();

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

Scopes

Parameters

Responses


scoutSearch

This is a wrapper around several SP-API calls for loading product, offers, and pricing data.


/api/scout/search/{query}

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/scout/search/{query}?marketplace=marketplace_example&pricing=&offers=&parent="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V1Api;

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

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

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

        // Create an instance of the API class
        V1Api apiInstance = new V1Api();
        String query = query_example; // String | 
        String xAccessToken = xAccessToken_example; // String | An LWA access token
        String marketplace = marketplace_example; // String | Specific marketplace of the requested shipments. Defaults to current marketplace set in ScanPower.
        oas_any_type_not_mapped pricing = ; // oas_any_type_not_mapped | Load pricing data
        oas_any_type_not_mapped offers = ; // oas_any_type_not_mapped | Load offers
        oas_any_type_not_mapped parent = ; // oas_any_type_not_mapped | Load parent ASIN data, if any

        try {
            scoutSearch_200_response result = apiInstance.scoutSearch(query, xAccessToken, marketplace, pricing, offers, parent);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V1Api#scoutSearch");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String query = new String(); // String | 
final String xAccessToken = new String(); // String | An LWA access token
final String marketplace = new String(); // String | Specific marketplace of the requested shipments. Defaults to current marketplace set in ScanPower.
final oas_any_type_not_mapped pricing = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | Load pricing data
final oas_any_type_not_mapped offers = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | Load offers
final oas_any_type_not_mapped parent = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | Load parent ASIN data, if any

try {
    final result = await api_instance.scoutSearch(query, xAccessToken, marketplace, pricing, offers, parent);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->scoutSearch: $e\n');
}

import org.openapitools.client.api.V1Api;

public class V1ApiExample {
    public static void main(String[] args) {
        V1Api apiInstance = new V1Api();
        String query = query_example; // String | 
        String xAccessToken = xAccessToken_example; // String | An LWA access token
        String marketplace = marketplace_example; // String | Specific marketplace of the requested shipments. Defaults to current marketplace set in ScanPower.
        oas_any_type_not_mapped pricing = ; // oas_any_type_not_mapped | Load pricing data
        oas_any_type_not_mapped offers = ; // oas_any_type_not_mapped | Load offers
        oas_any_type_not_mapped parent = ; // oas_any_type_not_mapped | Load parent ASIN data, if any

        try {
            scoutSearch_200_response result = apiInstance.scoutSearch(query, xAccessToken, marketplace, pricing, offers, parent);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V1Api#scoutSearch");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
V1Api *apiInstance = [[V1Api alloc] init];
String *query = query_example; //  (default to null)
String *xAccessToken = xAccessToken_example; // An LWA access token (optional) (default to null)
String *marketplace = marketplace_example; // Specific marketplace of the requested shipments. Defaults to current marketplace set in ScanPower. (optional) (default to null)
oas_any_type_not_mapped *pricing = ; // Load pricing data (optional) (default to null)
oas_any_type_not_mapped *offers = ; // Load offers (optional) (default to null)
oas_any_type_not_mapped *parent = ; // Load parent ASIN data, if any (optional) (default to null)

[apiInstance scoutSearchWith:query
    xAccessToken:xAccessToken
    marketplace:marketplace
    pricing:pricing
    offers:offers
    parent:parent
              completionHandler: ^(scoutSearch_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.V1Api()
var query = query_example; // {String} 
var opts = {
  'xAccessToken': xAccessToken_example, // {String} An LWA access token
  'marketplace': marketplace_example, // {String} Specific marketplace of the requested shipments. Defaults to current marketplace set in ScanPower.
  'pricing': , // {oas_any_type_not_mapped} Load pricing data
  'offers': , // {oas_any_type_not_mapped} Load offers
  'parent':  // {oas_any_type_not_mapped} Load parent ASIN data, if any
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.scoutSearch(query, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new V1Api();
            var query = query_example;  // String |  (default to null)
            var xAccessToken = xAccessToken_example;  // String | An LWA access token (optional)  (default to null)
            var marketplace = marketplace_example;  // String | Specific marketplace of the requested shipments. Defaults to current marketplace set in ScanPower. (optional)  (default to null)
            var pricing = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | Load pricing data (optional)  (default to null)
            var offers = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | Load offers (optional)  (default to null)
            var parent = new oas_any_type_not_mapped(); // oas_any_type_not_mapped | Load parent ASIN data, if any (optional)  (default to null)

            try {
                scoutSearch_200_response result = apiInstance.scoutSearch(query, xAccessToken, marketplace, pricing, offers, parent);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V1Api.scoutSearch: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V1Api();
$query = query_example; // String | 
$xAccessToken = xAccessToken_example; // String | An LWA access token
$marketplace = marketplace_example; // String | Specific marketplace of the requested shipments. Defaults to current marketplace set in ScanPower.
$pricing = ; // oas_any_type_not_mapped | Load pricing data
$offers = ; // oas_any_type_not_mapped | Load offers
$parent = ; // oas_any_type_not_mapped | Load parent ASIN data, if any

try {
    $result = $api_instance->scoutSearch($query, $xAccessToken, $marketplace, $pricing, $offers, $parent);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V1Api->scoutSearch: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V1Api;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V1Api->new();
my $query = query_example; # String | 
my $xAccessToken = xAccessToken_example; # String | An LWA access token
my $marketplace = marketplace_example; # String | Specific marketplace of the requested shipments. Defaults to current marketplace set in ScanPower.
my $pricing = ; # oas_any_type_not_mapped | Load pricing data
my $offers = ; # oas_any_type_not_mapped | Load offers
my $parent = ; # oas_any_type_not_mapped | Load parent ASIN data, if any

eval {
    my $result = $api_instance->scoutSearch(query => $query, xAccessToken => $xAccessToken, marketplace => $marketplace, pricing => $pricing, offers => $offers, parent => $parent);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V1Api->scoutSearch: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.V1Api()
query = query_example # String |  (default to null)
xAccessToken = xAccessToken_example # String | An LWA access token (optional) (default to null)
marketplace = marketplace_example # String | Specific marketplace of the requested shipments. Defaults to current marketplace set in ScanPower. (optional) (default to null)
pricing =  # oas_any_type_not_mapped | Load pricing data (optional) (default to null)
offers =  # oas_any_type_not_mapped | Load offers (optional) (default to null)
parent =  # oas_any_type_not_mapped | Load parent ASIN data, if any (optional) (default to null)

try:
    api_response = api_instance.scout_search(query, xAccessToken=xAccessToken, marketplace=marketplace, pricing=pricing, offers=offers, parent=parent)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V1Api->scoutSearch: %s\n" % e)
extern crate V1Api;

pub fn main() {
    let query = query_example; // String
    let xAccessToken = xAccessToken_example; // String
    let marketplace = marketplace_example; // String
    let pricing = ; // oas_any_type_not_mapped
    let offers = ; // oas_any_type_not_mapped
    let parent = ; // oas_any_type_not_mapped

    let mut context = V1Api::Context::default();
    let result = client.scoutSearch(query, xAccessToken, marketplace, pricing, offers, parent, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
query*
String
Required
Header parameters
Name Description
X-Access-Token
String
An LWA access token
Query parameters
Name Description
marketplace
String
Specific marketplace of the requested shipments. Defaults to current marketplace set in ScanPower.
pricing
oas_any_type_not_mapped
Load pricing data
offers
oas_any_type_not_mapped
Load offers
parent
oas_any_type_not_mapped
Load parent ASIN data, if any

Responses


V1Batch

createInboundPlanFromBatch

Create an inbound plan from the items in the provided batch


/api/batch/{batch_id}/inbound_plan

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/batch/{batch_id}/inbound_plan"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V1BatchApi;

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

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

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

        // Create an instance of the API class
        V1BatchApi apiInstance = new V1BatchApi();
        String batchId = batchId_example; // String | 

        try {
            createInboundPlanFromBatch_200_response result = apiInstance.createInboundPlanFromBatch(batchId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V1BatchApi#createInboundPlanFromBatch");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String batchId = new String(); // String | 

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

import org.openapitools.client.api.V1BatchApi;

public class V1BatchApiExample {
    public static void main(String[] args) {
        V1BatchApi apiInstance = new V1BatchApi();
        String batchId = batchId_example; // String | 

        try {
            createInboundPlanFromBatch_200_response result = apiInstance.createInboundPlanFromBatch(batchId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V1BatchApi#createInboundPlanFromBatch");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
V1BatchApi *apiInstance = [[V1BatchApi alloc] init];
String *batchId = batchId_example; //  (default to null)

[apiInstance createInboundPlanFromBatchWith:batchId
              completionHandler: ^(createInboundPlanFromBatch_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.V1BatchApi()
var batchId = batchId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createInboundPlanFromBatch(batchId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new V1BatchApi();
            var batchId = batchId_example;  // String |  (default to null)

            try {
                createInboundPlanFromBatch_200_response result = apiInstance.createInboundPlanFromBatch(batchId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V1BatchApi.createInboundPlanFromBatch: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V1BatchApi();
$batchId = batchId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V1BatchApi->new();
my $batchId = batchId_example; # String | 

eval {
    my $result = $api_instance->createInboundPlanFromBatch(batchId => $batchId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V1BatchApi->createInboundPlanFromBatch: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.V1BatchApi()
batchId = batchId_example # String |  (default to null)

try:
    api_response = api_instance.create_inbound_plan_from_batch(batchId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V1BatchApi->createInboundPlanFromBatch: %s\n" % e)
extern crate V1BatchApi;

pub fn main() {
    let batchId = batchId_example; // String

    let mut context = V1BatchApi::Context::default();
    let result = client.createInboundPlanFromBatch(batchId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
batch_id*
String
Required

Responses

Name Type Format Description
x-request-id String

getInboundPlans

Load the inbound plans associated with the given batch


/api/batch/{batch_id}/inbound_plan

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/batch/{batch_id}/inbound_plan"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V1BatchApi;

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

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

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

        // Create an instance of the API class
        V1BatchApi apiInstance = new V1BatchApi();
        String batchId = batchId_example; // String | 

        try {
            getInboundPlans_200_response result = apiInstance.getInboundPlans(batchId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V1BatchApi#getInboundPlans");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String batchId = new String(); // String | 

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

import org.openapitools.client.api.V1BatchApi;

public class V1BatchApiExample {
    public static void main(String[] args) {
        V1BatchApi apiInstance = new V1BatchApi();
        String batchId = batchId_example; // String | 

        try {
            getInboundPlans_200_response result = apiInstance.getInboundPlans(batchId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V1BatchApi#getInboundPlans");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
V1BatchApi *apiInstance = [[V1BatchApi alloc] init];
String *batchId = batchId_example; //  (default to null)

[apiInstance getInboundPlansWith:batchId
              completionHandler: ^(getInboundPlans_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.V1BatchApi()
var batchId = batchId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getInboundPlans(batchId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new V1BatchApi();
            var batchId = batchId_example;  // String |  (default to null)

            try {
                getInboundPlans_200_response result = apiInstance.getInboundPlans(batchId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V1BatchApi.getInboundPlans: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V1BatchApi();
$batchId = batchId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V1BatchApi->new();
my $batchId = batchId_example; # String | 

eval {
    my $result = $api_instance->getInboundPlans(batchId => $batchId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V1BatchApi->getInboundPlans: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.V1BatchApi()
batchId = batchId_example # String |  (default to null)

try:
    api_response = api_instance.get_inbound_plans(batchId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V1BatchApi->getInboundPlans: %s\n" % e)
extern crate V1BatchApi;

pub fn main() {
    let batchId = batchId_example; // String

    let mut context = V1BatchApi::Context::default();
    let result = client.getInboundPlans(batchId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
batch_id*
String
Required

Responses

Name Type Format Description
x-request-id String

submitBoxes

Send packed box information to Amazon


/api/batch/{batch_id}/submit_boxes

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/batch/{batch_id}/submit_boxes"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V1BatchApi;

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

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

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

        // Create an instance of the API class
        V1BatchApi apiInstance = new V1BatchApi();
        String batchId = batchId_example; // String | 

        try {
            submitBoxes_200_response result = apiInstance.submitBoxes(batchId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V1BatchApi#submitBoxes");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String batchId = new String(); // String | 

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

import org.openapitools.client.api.V1BatchApi;

public class V1BatchApiExample {
    public static void main(String[] args) {
        V1BatchApi apiInstance = new V1BatchApi();
        String batchId = batchId_example; // String | 

        try {
            submitBoxes_200_response result = apiInstance.submitBoxes(batchId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V1BatchApi#submitBoxes");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
V1BatchApi *apiInstance = [[V1BatchApi alloc] init];
String *batchId = batchId_example; //  (default to null)

[apiInstance submitBoxesWith:batchId
              completionHandler: ^(submitBoxes_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.V1BatchApi()
var batchId = batchId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.submitBoxes(batchId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new V1BatchApi();
            var batchId = batchId_example;  // String |  (default to null)

            try {
                submitBoxes_200_response result = apiInstance.submitBoxes(batchId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V1BatchApi.submitBoxes: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V1BatchApi();
$batchId = batchId_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V1BatchApi->new();
my $batchId = batchId_example; # String | 

eval {
    my $result = $api_instance->submitBoxes(batchId => $batchId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V1BatchApi->submitBoxes: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.V1BatchApi()
batchId = batchId_example # String |  (default to null)

try:
    api_response = api_instance.submit_boxes(batchId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V1BatchApi->submitBoxes: %s\n" % e)
extern crate V1BatchApi;

pub fn main() {
    let batchId = batchId_example; // String

    let mut context = V1BatchApi::Context::default();
    let result = client.submitBoxes(batchId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
batch_id*
String
Required

Responses

Name Type Format Description
x-request-id String

V2Boxes

deleteBox


/api/v2/box/{box_id}

Usage and SDK Samples

curl -X DELETE \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/v2/box/{box_id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2BoxesApi;

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

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

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

        // Create an instance of the API class
        V2BoxesApi apiInstance = new V2BoxesApi();
        String boxId = boxId_example; // String | The id of the box to delete

        try {
            insertBox_200_response result = apiInstance.deleteBox(boxId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2BoxesApi#deleteBox");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String boxId = new String(); // String | The id of the box to delete

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

import org.openapitools.client.api.V2BoxesApi;

public class V2BoxesApiExample {
    public static void main(String[] args) {
        V2BoxesApi apiInstance = new V2BoxesApi();
        String boxId = boxId_example; // String | The id of the box to delete

        try {
            insertBox_200_response result = apiInstance.deleteBox(boxId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2BoxesApi#deleteBox");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
V2BoxesApi *apiInstance = [[V2BoxesApi alloc] init];
String *boxId = boxId_example; // The id of the box to delete (default to null)

[apiInstance deleteBoxWith:boxId
              completionHandler: ^(insertBox_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.V2BoxesApi()
var boxId = boxId_example; // {String} The id of the box to delete

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteBox(boxId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new V2BoxesApi();
            var boxId = boxId_example;  // String | The id of the box to delete (default to null)

            try {
                insertBox_200_response result = apiInstance.deleteBox(boxId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2BoxesApi.deleteBox: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2BoxesApi();
$boxId = boxId_example; // String | The id of the box to delete

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2BoxesApi->new();
my $boxId = boxId_example; # String | The id of the box to delete

eval {
    my $result = $api_instance->deleteBox(boxId => $boxId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2BoxesApi->deleteBox: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.V2BoxesApi()
boxId = boxId_example # String | The id of the box to delete (default to null)

try:
    api_response = api_instance.delete_box(boxId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2BoxesApi->deleteBox: %s\n" % e)
extern crate V2BoxesApi;

pub fn main() {
    let boxId = boxId_example; // String

    let mut context = V2BoxesApi::Context::default();
    let result = client.deleteBox(boxId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
box_id*
String
The id of the box to delete
Required

Responses


deleteBoxItem


/api/v2/box/{box_id}/items/{sku}

Usage and SDK Samples

curl -X DELETE \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/v2/box/{box_id}/items/{sku}?box_created=boxCreated_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2BoxesApi;

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

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

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

        // Create an instance of the API class
        V2BoxesApi apiInstance = new V2BoxesApi();
        String boxId = boxId_example; // String | The id of the box in which the item to delete resides
        String sku = sku_example; // String | The SKU of the box item to delete
        String boxCreated = boxCreated_example; // String | The timestamp the box with ID `box_id` was created

        try {
            insertBoxItem_200_response result = apiInstance.deleteBoxItem(boxId, sku, boxCreated);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2BoxesApi#deleteBoxItem");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String boxId = new String(); // String | The id of the box in which the item to delete resides
final String sku = new String(); // String | The SKU of the box item to delete
final String boxCreated = new String(); // String | The timestamp the box with ID `box_id` was created

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

import org.openapitools.client.api.V2BoxesApi;

public class V2BoxesApiExample {
    public static void main(String[] args) {
        V2BoxesApi apiInstance = new V2BoxesApi();
        String boxId = boxId_example; // String | The id of the box in which the item to delete resides
        String sku = sku_example; // String | The SKU of the box item to delete
        String boxCreated = boxCreated_example; // String | The timestamp the box with ID `box_id` was created

        try {
            insertBoxItem_200_response result = apiInstance.deleteBoxItem(boxId, sku, boxCreated);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2BoxesApi#deleteBoxItem");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
V2BoxesApi *apiInstance = [[V2BoxesApi alloc] init];
String *boxId = boxId_example; // The id of the box in which the item to delete resides (default to null)
String *sku = sku_example; // The SKU of the box item to delete (default to null)
String *boxCreated = boxCreated_example; // The timestamp the box with ID `box_id` was created (default to null)

[apiInstance deleteBoxItemWith:boxId
    sku:sku
    boxCreated:boxCreated
              completionHandler: ^(insertBoxItem_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.V2BoxesApi()
var boxId = boxId_example; // {String} The id of the box in which the item to delete resides
var sku = sku_example; // {String} The SKU of the box item to delete
var boxCreated = boxCreated_example; // {String} The timestamp the box with ID `box_id` was created

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteBoxItem(boxId, sku, boxCreated, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new V2BoxesApi();
            var boxId = boxId_example;  // String | The id of the box in which the item to delete resides (default to null)
            var sku = sku_example;  // String | The SKU of the box item to delete (default to null)
            var boxCreated = boxCreated_example;  // String | The timestamp the box with ID `box_id` was created (default to null)

            try {
                insertBoxItem_200_response result = apiInstance.deleteBoxItem(boxId, sku, boxCreated);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2BoxesApi.deleteBoxItem: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2BoxesApi();
$boxId = boxId_example; // String | The id of the box in which the item to delete resides
$sku = sku_example; // String | The SKU of the box item to delete
$boxCreated = boxCreated_example; // String | The timestamp the box with ID `box_id` was created

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2BoxesApi->new();
my $boxId = boxId_example; # String | The id of the box in which the item to delete resides
my $sku = sku_example; # String | The SKU of the box item to delete
my $boxCreated = boxCreated_example; # String | The timestamp the box with ID `box_id` was created

eval {
    my $result = $api_instance->deleteBoxItem(boxId => $boxId, sku => $sku, boxCreated => $boxCreated);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2BoxesApi->deleteBoxItem: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.V2BoxesApi()
boxId = boxId_example # String | The id of the box in which the item to delete resides (default to null)
sku = sku_example # String | The SKU of the box item to delete (default to null)
boxCreated = boxCreated_example # String | The timestamp the box with ID `box_id` was created (default to null)

try:
    api_response = api_instance.delete_box_item(boxId, sku, boxCreated)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2BoxesApi->deleteBoxItem: %s\n" % e)
extern crate V2BoxesApi;

pub fn main() {
    let boxId = boxId_example; // String
    let sku = sku_example; // String
    let boxCreated = boxCreated_example; // String

    let mut context = V2BoxesApi::Context::default();
    let result = client.deleteBoxItem(boxId, sku, boxCreated, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
box_id*
String
The id of the box in which the item to delete resides
Required
sku*
String
The SKU of the box item to delete
Required
Query parameters
Name Description
box_created*
String
The timestamp the box with ID `box_id` was created
Required

Responses


insertBox


/api/v2/box

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/v2/box" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2BoxesApi;

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

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

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

        // Create an instance of the API class
        V2BoxesApi apiInstance = new V2BoxesApi();
        InsertBoxRequest insertBoxRequest = ; // InsertBoxRequest | 

        try {
            insertBox_200_response result = apiInstance.insertBox(insertBoxRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2BoxesApi#insertBox");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final InsertBoxRequest insertBoxRequest = new InsertBoxRequest(); // InsertBoxRequest | 

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

import org.openapitools.client.api.V2BoxesApi;

public class V2BoxesApiExample {
    public static void main(String[] args) {
        V2BoxesApi apiInstance = new V2BoxesApi();
        InsertBoxRequest insertBoxRequest = ; // InsertBoxRequest | 

        try {
            insertBox_200_response result = apiInstance.insertBox(insertBoxRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2BoxesApi#insertBox");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
V2BoxesApi *apiInstance = [[V2BoxesApi alloc] init];
InsertBoxRequest *insertBoxRequest = ; //  (optional)

[apiInstance insertBoxWith:insertBoxRequest
              completionHandler: ^(insertBox_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.V2BoxesApi()
var opts = {
  'insertBoxRequest':  // {InsertBoxRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.insertBox(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new V2BoxesApi();
            var insertBoxRequest = new InsertBoxRequest(); // InsertBoxRequest |  (optional) 

            try {
                insertBox_200_response result = apiInstance.insertBox(insertBoxRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2BoxesApi.insertBox: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2BoxesApi();
$insertBoxRequest = ; // InsertBoxRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2BoxesApi->new();
my $insertBoxRequest = WWW::OPenAPIClient::Object::InsertBoxRequest->new(); # InsertBoxRequest | 

eval {
    my $result = $api_instance->insertBox(insertBoxRequest => $insertBoxRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2BoxesApi->insertBox: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.V2BoxesApi()
insertBoxRequest =  # InsertBoxRequest |  (optional)

try:
    api_response = api_instance.insert_box(insertBoxRequest=insertBoxRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2BoxesApi->insertBox: %s\n" % e)
extern crate V2BoxesApi;

pub fn main() {
    let insertBoxRequest = ; // InsertBoxRequest

    let mut context = V2BoxesApi::Context::default();
    let result = client.insertBox(insertBoxRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
insertBoxRequest

Responses


insertBoxItem


/api/v2/box/{box_id}/items

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/v2/box/{box_id}/items?box_created=boxCreated_example" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2BoxesApi;

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

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

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

        // Create an instance of the API class
        V2BoxesApi apiInstance = new V2BoxesApi();
        String boxId = boxId_example; // String | The id of the box to get
        String boxCreated = boxCreated_example; // String | The timestamp the box with ID `box_id` was created
        InsertBoxItemRequest insertBoxItemRequest = ; // InsertBoxItemRequest | 

        try {
            insertBoxItem_200_response result = apiInstance.insertBoxItem(boxId, boxCreated, insertBoxItemRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2BoxesApi#insertBoxItem");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String boxId = new String(); // String | The id of the box to get
final String boxCreated = new String(); // String | The timestamp the box with ID `box_id` was created
final InsertBoxItemRequest insertBoxItemRequest = new InsertBoxItemRequest(); // InsertBoxItemRequest | 

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

import org.openapitools.client.api.V2BoxesApi;

public class V2BoxesApiExample {
    public static void main(String[] args) {
        V2BoxesApi apiInstance = new V2BoxesApi();
        String boxId = boxId_example; // String | The id of the box to get
        String boxCreated = boxCreated_example; // String | The timestamp the box with ID `box_id` was created
        InsertBoxItemRequest insertBoxItemRequest = ; // InsertBoxItemRequest | 

        try {
            insertBoxItem_200_response result = apiInstance.insertBoxItem(boxId, boxCreated, insertBoxItemRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2BoxesApi#insertBoxItem");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
V2BoxesApi *apiInstance = [[V2BoxesApi alloc] init];
String *boxId = boxId_example; // The id of the box to get (default to null)
String *boxCreated = boxCreated_example; // The timestamp the box with ID `box_id` was created (default to null)
InsertBoxItemRequest *insertBoxItemRequest = ; //  (optional)

[apiInstance insertBoxItemWith:boxId
    boxCreated:boxCreated
    insertBoxItemRequest:insertBoxItemRequest
              completionHandler: ^(insertBoxItem_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.V2BoxesApi()
var boxId = boxId_example; // {String} The id of the box to get
var boxCreated = boxCreated_example; // {String} The timestamp the box with ID `box_id` was created
var opts = {
  'insertBoxItemRequest':  // {InsertBoxItemRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.insertBoxItem(boxId, boxCreated, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new V2BoxesApi();
            var boxId = boxId_example;  // String | The id of the box to get (default to null)
            var boxCreated = boxCreated_example;  // String | The timestamp the box with ID `box_id` was created (default to null)
            var insertBoxItemRequest = new InsertBoxItemRequest(); // InsertBoxItemRequest |  (optional) 

            try {
                insertBoxItem_200_response result = apiInstance.insertBoxItem(boxId, boxCreated, insertBoxItemRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2BoxesApi.insertBoxItem: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2BoxesApi();
$boxId = boxId_example; // String | The id of the box to get
$boxCreated = boxCreated_example; // String | The timestamp the box with ID `box_id` was created
$insertBoxItemRequest = ; // InsertBoxItemRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2BoxesApi->new();
my $boxId = boxId_example; # String | The id of the box to get
my $boxCreated = boxCreated_example; # String | The timestamp the box with ID `box_id` was created
my $insertBoxItemRequest = WWW::OPenAPIClient::Object::InsertBoxItemRequest->new(); # InsertBoxItemRequest | 

eval {
    my $result = $api_instance->insertBoxItem(boxId => $boxId, boxCreated => $boxCreated, insertBoxItemRequest => $insertBoxItemRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2BoxesApi->insertBoxItem: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.V2BoxesApi()
boxId = boxId_example # String | The id of the box to get (default to null)
boxCreated = boxCreated_example # String | The timestamp the box with ID `box_id` was created (default to null)
insertBoxItemRequest =  # InsertBoxItemRequest |  (optional)

try:
    api_response = api_instance.insert_box_item(boxId, boxCreated, insertBoxItemRequest=insertBoxItemRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2BoxesApi->insertBoxItem: %s\n" % e)
extern crate V2BoxesApi;

pub fn main() {
    let boxId = boxId_example; // String
    let boxCreated = boxCreated_example; // String
    let insertBoxItemRequest = ; // InsertBoxItemRequest

    let mut context = V2BoxesApi::Context::default();
    let result = client.insertBoxItem(boxId, boxCreated, insertBoxItemRequest, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
box_id*
String
The id of the box to get
Required
Body parameters
Name Description
insertBoxItemRequest

Query parameters
Name Description
box_created*
String
The timestamp the box with ID `box_id` was created
Required

Responses


selectBox


/api/v2/box/{box_id}

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/v2/box/{box_id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2BoxesApi;

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

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

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

        // Create an instance of the API class
        V2BoxesApi apiInstance = new V2BoxesApi();
        String boxId = boxId_example; // String | The id of the box to get

        try {
            insertBox_200_response result = apiInstance.selectBox(boxId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2BoxesApi#selectBox");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String boxId = new String(); // String | The id of the box to get

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

import org.openapitools.client.api.V2BoxesApi;

public class V2BoxesApiExample {
    public static void main(String[] args) {
        V2BoxesApi apiInstance = new V2BoxesApi();
        String boxId = boxId_example; // String | The id of the box to get

        try {
            insertBox_200_response result = apiInstance.selectBox(boxId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2BoxesApi#selectBox");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
V2BoxesApi *apiInstance = [[V2BoxesApi alloc] init];
String *boxId = boxId_example; // The id of the box to get (default to null)

[apiInstance selectBoxWith:boxId
              completionHandler: ^(insertBox_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.V2BoxesApi()
var boxId = boxId_example; // {String} The id of the box to get

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.selectBox(boxId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new V2BoxesApi();
            var boxId = boxId_example;  // String | The id of the box to get (default to null)

            try {
                insertBox_200_response result = apiInstance.selectBox(boxId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2BoxesApi.selectBox: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2BoxesApi();
$boxId = boxId_example; // String | The id of the box to get

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2BoxesApi->new();
my $boxId = boxId_example; # String | The id of the box to get

eval {
    my $result = $api_instance->selectBox(boxId => $boxId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2BoxesApi->selectBox: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.V2BoxesApi()
boxId = boxId_example # String | The id of the box to get (default to null)

try:
    api_response = api_instance.select_box(boxId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2BoxesApi->selectBox: %s\n" % e)
extern crate V2BoxesApi;

pub fn main() {
    let boxId = boxId_example; // String

    let mut context = V2BoxesApi::Context::default();
    let result = client.selectBox(boxId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
box_id*
String
The id of the box to get
Required

Responses


selectBoxItems


/api/v2/box/{box_id}/items

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/v2/box/{box_id}/items?box_created=boxCreated_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2BoxesApi;

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

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

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

        // Create an instance of the API class
        V2BoxesApi apiInstance = new V2BoxesApi();
        String boxId = boxId_example; // String | The id of the box to get
        String boxCreated = boxCreated_example; // String | The timestamp the box with ID `box_id` was created

        try {
            selectBoxItems_200_response result = apiInstance.selectBoxItems(boxId, boxCreated);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2BoxesApi#selectBoxItems");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String boxId = new String(); // String | The id of the box to get
final String boxCreated = new String(); // String | The timestamp the box with ID `box_id` was created

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

import org.openapitools.client.api.V2BoxesApi;

public class V2BoxesApiExample {
    public static void main(String[] args) {
        V2BoxesApi apiInstance = new V2BoxesApi();
        String boxId = boxId_example; // String | The id of the box to get
        String boxCreated = boxCreated_example; // String | The timestamp the box with ID `box_id` was created

        try {
            selectBoxItems_200_response result = apiInstance.selectBoxItems(boxId, boxCreated);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2BoxesApi#selectBoxItems");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
V2BoxesApi *apiInstance = [[V2BoxesApi alloc] init];
String *boxId = boxId_example; // The id of the box to get (default to null)
String *boxCreated = boxCreated_example; // The timestamp the box with ID `box_id` was created (default to null)

[apiInstance selectBoxItemsWith:boxId
    boxCreated:boxCreated
              completionHandler: ^(selectBoxItems_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.V2BoxesApi()
var boxId = boxId_example; // {String} The id of the box to get
var boxCreated = boxCreated_example; // {String} The timestamp the box with ID `box_id` was created

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.selectBoxItems(boxId, boxCreated, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new V2BoxesApi();
            var boxId = boxId_example;  // String | The id of the box to get (default to null)
            var boxCreated = boxCreated_example;  // String | The timestamp the box with ID `box_id` was created (default to null)

            try {
                selectBoxItems_200_response result = apiInstance.selectBoxItems(boxId, boxCreated);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2BoxesApi.selectBoxItems: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2BoxesApi();
$boxId = boxId_example; // String | The id of the box to get
$boxCreated = boxCreated_example; // String | The timestamp the box with ID `box_id` was created

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2BoxesApi->new();
my $boxId = boxId_example; # String | The id of the box to get
my $boxCreated = boxCreated_example; # String | The timestamp the box with ID `box_id` was created

eval {
    my $result = $api_instance->selectBoxItems(boxId => $boxId, boxCreated => $boxCreated);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2BoxesApi->selectBoxItems: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.V2BoxesApi()
boxId = boxId_example # String | The id of the box to get (default to null)
boxCreated = boxCreated_example # String | The timestamp the box with ID `box_id` was created (default to null)

try:
    api_response = api_instance.select_box_items(boxId, boxCreated)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2BoxesApi->selectBoxItems: %s\n" % e)
extern crate V2BoxesApi;

pub fn main() {
    let boxId = boxId_example; // String
    let boxCreated = boxCreated_example; // String

    let mut context = V2BoxesApi::Context::default();
    let result = client.selectBoxItems(boxId, boxCreated, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
box_id*
String
The id of the box to get
Required
Query parameters
Name Description
box_created*
String
The timestamp the box with ID `box_id` was created
Required

Responses


selectBoxes


/api/v2/box

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/v2/box?v1_batch_id=v1BatchId_example&v2_batch_id=v2BatchId_example&shipment_id=shipmentId_example&with="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2BoxesApi;

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

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

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

        // Create an instance of the API class
        V2BoxesApi apiInstance = new V2BoxesApi();
        String v1BatchId = v1BatchId_example; // String | The id of the v1 batch to load boxes for
        String v2BatchId = v2BatchId_example; // String | The id of the v2 batch to load boxes for
        String shipmentId = shipmentId_example; // String | The id of the v2 shipment to load boxes for
        array[String] with = ; // array[String] | Comma separated list of zero or more of `configuration` or `box_items`.

        try {
            selectBoxes_200_response result = apiInstance.selectBoxes(v1BatchId, v2BatchId, shipmentId, with);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2BoxesApi#selectBoxes");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String v1BatchId = new String(); // String | The id of the v1 batch to load boxes for
final String v2BatchId = new String(); // String | The id of the v2 batch to load boxes for
final String shipmentId = new String(); // String | The id of the v2 shipment to load boxes for
final array[String] with = new array[String](); // array[String] | Comma separated list of zero or more of `configuration` or `box_items`.

try {
    final result = await api_instance.selectBoxes(v1BatchId, v2BatchId, shipmentId, with);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->selectBoxes: $e\n');
}

import org.openapitools.client.api.V2BoxesApi;

public class V2BoxesApiExample {
    public static void main(String[] args) {
        V2BoxesApi apiInstance = new V2BoxesApi();
        String v1BatchId = v1BatchId_example; // String | The id of the v1 batch to load boxes for
        String v2BatchId = v2BatchId_example; // String | The id of the v2 batch to load boxes for
        String shipmentId = shipmentId_example; // String | The id of the v2 shipment to load boxes for
        array[String] with = ; // array[String] | Comma separated list of zero or more of `configuration` or `box_items`.

        try {
            selectBoxes_200_response result = apiInstance.selectBoxes(v1BatchId, v2BatchId, shipmentId, with);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2BoxesApi#selectBoxes");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
V2BoxesApi *apiInstance = [[V2BoxesApi alloc] init];
String *v1BatchId = v1BatchId_example; // The id of the v1 batch to load boxes for (optional) (default to null)
String *v2BatchId = v2BatchId_example; // The id of the v2 batch to load boxes for (optional) (default to null)
String *shipmentId = shipmentId_example; // The id of the v2 shipment to load boxes for (optional) (default to null)
array[String] *with = ; // Comma separated list of zero or more of `configuration` or `box_items`. (optional) (default to null)

[apiInstance selectBoxesWith:v1BatchId
    v2BatchId:v2BatchId
    shipmentId:shipmentId
    with:with
              completionHandler: ^(selectBoxes_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.V2BoxesApi()
var opts = {
  'v1BatchId': v1BatchId_example, // {String} The id of the v1 batch to load boxes for
  'v2BatchId': v2BatchId_example, // {String} The id of the v2 batch to load boxes for
  'shipmentId': shipmentId_example, // {String} The id of the v2 shipment to load boxes for
  'with':  // {array[String]} Comma separated list of zero or more of `configuration` or `box_items`.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.selectBoxes(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new V2BoxesApi();
            var v1BatchId = v1BatchId_example;  // String | The id of the v1 batch to load boxes for (optional)  (default to null)
            var v2BatchId = v2BatchId_example;  // String | The id of the v2 batch to load boxes for (optional)  (default to null)
            var shipmentId = shipmentId_example;  // String | The id of the v2 shipment to load boxes for (optional)  (default to null)
            var with = new array[String](); // array[String] | Comma separated list of zero or more of `configuration` or `box_items`. (optional)  (default to null)

            try {
                selectBoxes_200_response result = apiInstance.selectBoxes(v1BatchId, v2BatchId, shipmentId, with);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2BoxesApi.selectBoxes: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2BoxesApi();
$v1BatchId = v1BatchId_example; // String | The id of the v1 batch to load boxes for
$v2BatchId = v2BatchId_example; // String | The id of the v2 batch to load boxes for
$shipmentId = shipmentId_example; // String | The id of the v2 shipment to load boxes for
$with = ; // array[String] | Comma separated list of zero or more of `configuration` or `box_items`.

try {
    $result = $api_instance->selectBoxes($v1BatchId, $v2BatchId, $shipmentId, $with);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2BoxesApi->selectBoxes: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2BoxesApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2BoxesApi->new();
my $v1BatchId = v1BatchId_example; # String | The id of the v1 batch to load boxes for
my $v2BatchId = v2BatchId_example; # String | The id of the v2 batch to load boxes for
my $shipmentId = shipmentId_example; # String | The id of the v2 shipment to load boxes for
my $with = []; # array[String] | Comma separated list of zero or more of `configuration` or `box_items`.

eval {
    my $result = $api_instance->selectBoxes(v1BatchId => $v1BatchId, v2BatchId => $v2BatchId, shipmentId => $shipmentId, with => $with);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2BoxesApi->selectBoxes: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.V2BoxesApi()
v1BatchId = v1BatchId_example # String | The id of the v1 batch to load boxes for (optional) (default to null)
v2BatchId = v2BatchId_example # String | The id of the v2 batch to load boxes for (optional) (default to null)
shipmentId = shipmentId_example # String | The id of the v2 shipment to load boxes for (optional) (default to null)
with =  # array[String] | Comma separated list of zero or more of `configuration` or `box_items`. (optional) (default to null)

try:
    api_response = api_instance.select_boxes(v1BatchId=v1BatchId, v2BatchId=v2BatchId, shipmentId=shipmentId, with=with)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2BoxesApi->selectBoxes: %s\n" % e)
extern crate V2BoxesApi;

pub fn main() {
    let v1BatchId = v1BatchId_example; // String
    let v2BatchId = v2BatchId_example; // String
    let shipmentId = shipmentId_example; // String
    let with = ; // array[String]

    let mut context = V2BoxesApi::Context::default();
    let result = client.selectBoxes(v1BatchId, v2BatchId, shipmentId, with, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
v1_batch_id
String
The id of the v1 batch to load boxes for
v2_batch_id
String
The id of the v2 batch to load boxes for
shipment_id
String
The id of the v2 shipment to load boxes for
with
array[String]
Comma separated list of zero or more of `configuration` or `box_items`.

Responses


updateBox


/api/v2/box/{box_id}

Usage and SDK Samples

curl -X PATCH \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/v2/box/{box_id}" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2BoxesApi;

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

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

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

        // Create an instance of the API class
        V2BoxesApi apiInstance = new V2BoxesApi();
        String boxId = boxId_example; // String | The id of the box to update
        V2BoxInput v2BoxInput = ; // V2BoxInput | 

        try {
            insertBox_200_response result = apiInstance.updateBox(boxId, v2BoxInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2BoxesApi#updateBox");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String boxId = new String(); // String | The id of the box to update
final V2BoxInput v2BoxInput = new V2BoxInput(); // V2BoxInput | 

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

import org.openapitools.client.api.V2BoxesApi;

public class V2BoxesApiExample {
    public static void main(String[] args) {
        V2BoxesApi apiInstance = new V2BoxesApi();
        String boxId = boxId_example; // String | The id of the box to update
        V2BoxInput v2BoxInput = ; // V2BoxInput | 

        try {
            insertBox_200_response result = apiInstance.updateBox(boxId, v2BoxInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2BoxesApi#updateBox");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
V2BoxesApi *apiInstance = [[V2BoxesApi alloc] init];
String *boxId = boxId_example; // The id of the box to update (default to null)
V2BoxInput *v2BoxInput = ; //  (optional)

[apiInstance updateBoxWith:boxId
    v2BoxInput:v2BoxInput
              completionHandler: ^(insertBox_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.V2BoxesApi()
var boxId = boxId_example; // {String} The id of the box to update
var opts = {
  'v2BoxInput':  // {V2BoxInput} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateBox(boxId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new V2BoxesApi();
            var boxId = boxId_example;  // String | The id of the box to update (default to null)
            var v2BoxInput = new V2BoxInput(); // V2BoxInput |  (optional) 

            try {
                insertBox_200_response result = apiInstance.updateBox(boxId, v2BoxInput);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2BoxesApi.updateBox: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2BoxesApi();
$boxId = boxId_example; // String | The id of the box to update
$v2BoxInput = ; // V2BoxInput | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2BoxesApi->new();
my $boxId = boxId_example; # String | The id of the box to update
my $v2BoxInput = WWW::OPenAPIClient::Object::V2BoxInput->new(); # V2BoxInput | 

eval {
    my $result = $api_instance->updateBox(boxId => $boxId, v2BoxInput => $v2BoxInput);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2BoxesApi->updateBox: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.V2BoxesApi()
boxId = boxId_example # String | The id of the box to update (default to null)
v2BoxInput =  # V2BoxInput |  (optional)

try:
    api_response = api_instance.update_box(boxId, v2BoxInput=v2BoxInput)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2BoxesApi->updateBox: %s\n" % e)
extern crate V2BoxesApi;

pub fn main() {
    let boxId = boxId_example; // String
    let v2BoxInput = ; // V2BoxInput

    let mut context = V2BoxesApi::Context::default();
    let result = client.updateBox(boxId, v2BoxInput, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
box_id*
String
The id of the box to update
Required
Body parameters
Name Description
v2BoxInput

Responses


updateBoxItem


/api/v2/box/{box_id}/items/{sku}

Usage and SDK Samples

curl -X PATCH \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/v2/box/{box_id}/items/{sku}?box_created=boxCreated_example" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2BoxesApi;

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

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

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

        // Create an instance of the API class
        V2BoxesApi apiInstance = new V2BoxesApi();
        String boxId = boxId_example; // String | The id of the box in which the item to update resides
        String sku = sku_example; // String | The SKU of the box item to update
        String boxCreated = boxCreated_example; // String | The timestamp the box with ID `box_id` was created
        V2BoxItemInput v2BoxItemInput = ; // V2BoxItemInput | 

        try {
            insertBoxItem_200_response result = apiInstance.updateBoxItem(boxId, sku, boxCreated, v2BoxItemInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2BoxesApi#updateBoxItem");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String boxId = new String(); // String | The id of the box in which the item to update resides
final String sku = new String(); // String | The SKU of the box item to update
final String boxCreated = new String(); // String | The timestamp the box with ID `box_id` was created
final V2BoxItemInput v2BoxItemInput = new V2BoxItemInput(); // V2BoxItemInput | 

try {
    final result = await api_instance.updateBoxItem(boxId, sku, boxCreated, v2BoxItemInput);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateBoxItem: $e\n');
}

import org.openapitools.client.api.V2BoxesApi;

public class V2BoxesApiExample {
    public static void main(String[] args) {
        V2BoxesApi apiInstance = new V2BoxesApi();
        String boxId = boxId_example; // String | The id of the box in which the item to update resides
        String sku = sku_example; // String | The SKU of the box item to update
        String boxCreated = boxCreated_example; // String | The timestamp the box with ID `box_id` was created
        V2BoxItemInput v2BoxItemInput = ; // V2BoxItemInput | 

        try {
            insertBoxItem_200_response result = apiInstance.updateBoxItem(boxId, sku, boxCreated, v2BoxItemInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2BoxesApi#updateBoxItem");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Create an instance of the API class
V2BoxesApi *apiInstance = [[V2BoxesApi alloc] init];
String *boxId = boxId_example; // The id of the box in which the item to update resides (default to null)
String *sku = sku_example; // The SKU of the box item to update (default to null)
String *boxCreated = boxCreated_example; // The timestamp the box with ID `box_id` was created (default to null)
V2BoxItemInput *v2BoxItemInput = ; //  (optional)

[apiInstance updateBoxItemWith:boxId
    sku:sku
    boxCreated:boxCreated
    v2BoxItemInput:v2BoxItemInput
              completionHandler: ^(insertBoxItem_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new ScanPowerApi.V2BoxesApi()
var boxId = boxId_example; // {String} The id of the box in which the item to update resides
var sku = sku_example; // {String} The SKU of the box item to update
var boxCreated = boxCreated_example; // {String} The timestamp the box with ID `box_id` was created
var opts = {
  'v2BoxItemInput':  // {V2BoxItemInput} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateBoxItem(boxId, sku, boxCreated, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new V2BoxesApi();
            var boxId = boxId_example;  // String | The id of the box in which the item to update resides (default to null)
            var sku = sku_example;  // String | The SKU of the box item to update (default to null)
            var boxCreated = boxCreated_example;  // String | The timestamp the box with ID `box_id` was created (default to null)
            var v2BoxItemInput = new V2BoxItemInput(); // V2BoxItemInput |  (optional) 

            try {
                insertBoxItem_200_response result = apiInstance.updateBoxItem(boxId, sku, boxCreated, v2BoxItemInput);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2BoxesApi.updateBoxItem: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2BoxesApi();
$boxId = boxId_example; // String | The id of the box in which the item to update resides
$sku = sku_example; // String | The SKU of the box item to update
$boxCreated = boxCreated_example; // String | The timestamp the box with ID `box_id` was created
$v2BoxItemInput = ; // V2BoxItemInput | 

try {
    $result = $api_instance->updateBoxItem($boxId, $sku, $boxCreated, $v2BoxItemInput);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2BoxesApi->updateBoxItem: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2BoxesApi;

# Configure Bearer (JWT) access token for authorization: bearer_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2BoxesApi->new();
my $boxId = boxId_example; # String | The id of the box in which the item to update resides
my $sku = sku_example; # String | The SKU of the box item to update
my $boxCreated = boxCreated_example; # String | The timestamp the box with ID `box_id` was created
my $v2BoxItemInput = WWW::OPenAPIClient::Object::V2BoxItemInput->new(); # V2BoxItemInput | 

eval {
    my $result = $api_instance->updateBoxItem(boxId => $boxId, sku => $sku, boxCreated => $boxCreated, v2BoxItemInput => $v2BoxItemInput);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2BoxesApi->updateBoxItem: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: bearer_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.V2BoxesApi()
boxId = boxId_example # String | The id of the box in which the item to update resides (default to null)
sku = sku_example # String | The SKU of the box item to update (default to null)
boxCreated = boxCreated_example # String | The timestamp the box with ID `box_id` was created (default to null)
v2BoxItemInput =  # V2BoxItemInput |  (optional)

try:
    api_response = api_instance.update_box_item(boxId, sku, boxCreated, v2BoxItemInput=v2BoxItemInput)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2BoxesApi->updateBoxItem: %s\n" % e)
extern crate V2BoxesApi;

pub fn main() {
    let boxId = boxId_example; // String
    let sku = sku_example; // String
    let boxCreated = boxCreated_example; // String
    let v2BoxItemInput = ; // V2BoxItemInput

    let mut context = V2BoxesApi::Context::default();
    let result = client.updateBoxItem(boxId, sku, boxCreated, v2BoxItemInput, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
box_id*
String
The id of the box in which the item to update resides
Required
sku*
String
The SKU of the box item to update
Required
Body parameters
Name Description
v2BoxItemInput

Query parameters
Name Description
box_created*
String
The timestamp the box with ID `box_id` was created
Required

Responses


V2InboundPlan

insertDeliveryWindowOption

Insert a delivery window option into our database


/api/v2/inbound-plan/{inbound_plan_id}/shipments/{shipment_id}/delivery-window-options/{delivery_window_option_id}

Usage and SDK Samples

curl -X PUT \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/v2/inbound-plan/{inbound_plan_id}/shipments/{shipment_id}/delivery-window-options/{delivery_window_option_id}" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2InboundPlanApi;

import java.io.File;
import java.util.*;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearer_auth
        HttpBearerAuth bearer_auth = (HttpBearerAuth) defaultClient.getAuthentication("bearer_auth");
        bearer_auth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        String deliveryWindowOptionId = deliveryWindowOptionId_example; // String | 
        V2DeliveryWindowOptionInput v2DeliveryWindowOptionInput = ; // V2DeliveryWindowOptionInput | 

        try {
            selectDeliveryWindowOption_200_response result = apiInstance.insertDeliveryWindowOption(inboundPlanId, shipmentId, deliveryWindowOptionId, v2DeliveryWindowOptionInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#insertDeliveryWindowOption");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String shipmentId = new String(); // String | 
final String deliveryWindowOptionId = new String(); // String | 
final V2DeliveryWindowOptionInput v2DeliveryWindowOptionInput = new V2DeliveryWindowOptionInput(); // V2DeliveryWindowOptionInput | 

try {
    final result = await api_instance.insertDeliveryWindowOption(inboundPlanId, shipmentId, deliveryWindowOptionId, v2DeliveryWindowOptionInput);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->insertDeliveryWindowOption: $e\n');
}

import org.openapitools.client.api.V2InboundPlanApi;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        String deliveryWindowOptionId = deliveryWindowOptionId_example; // String | 
        V2DeliveryWindowOptionInput v2DeliveryWindowOptionInput = ; // V2DeliveryWindowOptionInput | 

        try {
            selectDeliveryWindowOption_200_response result = apiInstance.insertDeliveryWindowOption(inboundPlanId, shipmentId, deliveryWindowOptionId, v2DeliveryWindowOptionInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#insertDeliveryWindowOption");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearer_auth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
V2InboundPlanApi *apiInstance = [[V2InboundPlanApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *shipmentId = shipmentId_example; //  (default to null)
String *deliveryWindowOptionId = deliveryWindowOptionId_example; //  (default to null)
V2DeliveryWindowOptionInput *v2DeliveryWindowOptionInput = ; //  (optional)

[apiInstance insertDeliveryWindowOptionWith:inboundPlanId
    shipmentId:shipmentId
    deliveryWindowOptionId:deliveryWindowOptionId
    v2DeliveryWindowOptionInput:v2DeliveryWindowOptionInput
              completionHandler: ^(selectDeliveryWindowOption_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearer_auth
var bearer_auth = defaultClient.authentications['bearer_auth'];
bearer_auth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ScanPowerApi.V2InboundPlanApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var shipmentId = shipmentId_example; // {String} 
var deliveryWindowOptionId = deliveryWindowOptionId_example; // {String} 
var opts = {
  'v2DeliveryWindowOptionInput':  // {V2DeliveryWindowOptionInput} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.insertDeliveryWindowOption(inboundPlanId, shipmentId, deliveryWindowOptionId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class insertDeliveryWindowOptionExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearer_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new V2InboundPlanApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var shipmentId = shipmentId_example;  // String |  (default to null)
            var deliveryWindowOptionId = deliveryWindowOptionId_example;  // String |  (default to null)
            var v2DeliveryWindowOptionInput = new V2DeliveryWindowOptionInput(); // V2DeliveryWindowOptionInput |  (optional) 

            try {
                selectDeliveryWindowOption_200_response result = apiInstance.insertDeliveryWindowOption(inboundPlanId, shipmentId, deliveryWindowOptionId, v2DeliveryWindowOptionInput);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2InboundPlanApi.insertDeliveryWindowOption: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer (JWT) access token for authorization: bearer_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2InboundPlanApi();
$inboundPlanId = inboundPlanId_example; // String | 
$shipmentId = shipmentId_example; // String | 
$deliveryWindowOptionId = deliveryWindowOptionId_example; // String | 
$v2DeliveryWindowOptionInput = ; // V2DeliveryWindowOptionInput | 

try {
    $result = $api_instance->insertDeliveryWindowOption($inboundPlanId, $shipmentId, $deliveryWindowOptionId, $v2DeliveryWindowOptionInput);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2InboundPlanApi->insertDeliveryWindowOption: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2InboundPlanApi;

# Configure Bearer (JWT) access token for authorization: bearer_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2InboundPlanApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $shipmentId = shipmentId_example; # String | 
my $deliveryWindowOptionId = deliveryWindowOptionId_example; # String | 
my $v2DeliveryWindowOptionInput = WWW::OPenAPIClient::Object::V2DeliveryWindowOptionInput->new(); # V2DeliveryWindowOptionInput | 

eval {
    my $result = $api_instance->insertDeliveryWindowOption(inboundPlanId => $inboundPlanId, shipmentId => $shipmentId, deliveryWindowOptionId => $deliveryWindowOptionId, v2DeliveryWindowOptionInput => $v2DeliveryWindowOptionInput);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2InboundPlanApi->insertDeliveryWindowOption: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: bearer_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.V2InboundPlanApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
shipmentId = shipmentId_example # String |  (default to null)
deliveryWindowOptionId = deliveryWindowOptionId_example # String |  (default to null)
v2DeliveryWindowOptionInput =  # V2DeliveryWindowOptionInput |  (optional)

try:
    api_response = api_instance.insert_delivery_window_option(inboundPlanId, shipmentId, deliveryWindowOptionId, v2DeliveryWindowOptionInput=v2DeliveryWindowOptionInput)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2InboundPlanApi->insertDeliveryWindowOption: %s\n" % e)
extern crate V2InboundPlanApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let shipmentId = shipmentId_example; // String
    let deliveryWindowOptionId = deliveryWindowOptionId_example; // String
    let v2DeliveryWindowOptionInput = ; // V2DeliveryWindowOptionInput

    let mut context = V2InboundPlanApi::Context::default();
    let result = client.insertDeliveryWindowOption(inboundPlanId, shipmentId, deliveryWindowOptionId, v2DeliveryWindowOptionInput, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
inbound_plan_id*
String
Required
shipment_id*
String
Required
delivery_window_option_id*
String
Required
Body parameters
Name Description
v2DeliveryWindowOptionInput

Responses


insertPackingOption

Store a packing option


/api/v2/inbound-plan/{inbound_plan_id}/packing-options/{packing_option_id}

Usage and SDK Samples

curl -X PUT \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/v2/inbound-plan/{inbound_plan_id}/packing-options/{packing_option_id}" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2InboundPlanApi;

import java.io.File;
import java.util.*;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearer_auth
        HttpBearerAuth bearer_auth = (HttpBearerAuth) defaultClient.getAuthentication("bearer_auth");
        bearer_auth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String packingOptionId = packingOptionId_example; // String | 
        InsertPackingOptionRequest insertPackingOptionRequest = ; // InsertPackingOptionRequest | 

        try {
            insertPackingOption_200_response result = apiInstance.insertPackingOption(inboundPlanId, packingOptionId, insertPackingOptionRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#insertPackingOption");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String packingOptionId = new String(); // String | 
final InsertPackingOptionRequest insertPackingOptionRequest = new InsertPackingOptionRequest(); // InsertPackingOptionRequest | 

try {
    final result = await api_instance.insertPackingOption(inboundPlanId, packingOptionId, insertPackingOptionRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->insertPackingOption: $e\n');
}

import org.openapitools.client.api.V2InboundPlanApi;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String packingOptionId = packingOptionId_example; // String | 
        InsertPackingOptionRequest insertPackingOptionRequest = ; // InsertPackingOptionRequest | 

        try {
            insertPackingOption_200_response result = apiInstance.insertPackingOption(inboundPlanId, packingOptionId, insertPackingOptionRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#insertPackingOption");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearer_auth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
V2InboundPlanApi *apiInstance = [[V2InboundPlanApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *packingOptionId = packingOptionId_example; //  (default to null)
InsertPackingOptionRequest *insertPackingOptionRequest = ; //  (optional)

[apiInstance insertPackingOptionWith:inboundPlanId
    packingOptionId:packingOptionId
    insertPackingOptionRequest:insertPackingOptionRequest
              completionHandler: ^(insertPackingOption_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearer_auth
var bearer_auth = defaultClient.authentications['bearer_auth'];
bearer_auth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ScanPowerApi.V2InboundPlanApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var packingOptionId = packingOptionId_example; // {String} 
var opts = {
  'insertPackingOptionRequest':  // {InsertPackingOptionRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.insertPackingOption(inboundPlanId, packingOptionId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class insertPackingOptionExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearer_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new V2InboundPlanApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var packingOptionId = packingOptionId_example;  // String |  (default to null)
            var insertPackingOptionRequest = new InsertPackingOptionRequest(); // InsertPackingOptionRequest |  (optional) 

            try {
                insertPackingOption_200_response result = apiInstance.insertPackingOption(inboundPlanId, packingOptionId, insertPackingOptionRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2InboundPlanApi.insertPackingOption: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer (JWT) access token for authorization: bearer_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2InboundPlanApi();
$inboundPlanId = inboundPlanId_example; // String | 
$packingOptionId = packingOptionId_example; // String | 
$insertPackingOptionRequest = ; // InsertPackingOptionRequest | 

try {
    $result = $api_instance->insertPackingOption($inboundPlanId, $packingOptionId, $insertPackingOptionRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2InboundPlanApi->insertPackingOption: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2InboundPlanApi;

# Configure Bearer (JWT) access token for authorization: bearer_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2InboundPlanApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $packingOptionId = packingOptionId_example; # String | 
my $insertPackingOptionRequest = WWW::OPenAPIClient::Object::InsertPackingOptionRequest->new(); # InsertPackingOptionRequest | 

eval {
    my $result = $api_instance->insertPackingOption(inboundPlanId => $inboundPlanId, packingOptionId => $packingOptionId, insertPackingOptionRequest => $insertPackingOptionRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2InboundPlanApi->insertPackingOption: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: bearer_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.V2InboundPlanApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
packingOptionId = packingOptionId_example # String |  (default to null)
insertPackingOptionRequest =  # InsertPackingOptionRequest |  (optional)

try:
    api_response = api_instance.insert_packing_option(inboundPlanId, packingOptionId, insertPackingOptionRequest=insertPackingOptionRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2InboundPlanApi->insertPackingOption: %s\n" % e)
extern crate V2InboundPlanApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let packingOptionId = packingOptionId_example; // String
    let insertPackingOptionRequest = ; // InsertPackingOptionRequest

    let mut context = V2InboundPlanApi::Context::default();
    let result = client.insertPackingOption(inboundPlanId, packingOptionId, insertPackingOptionRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
inbound_plan_id*
String
Required
packing_option_id*
String
Required
Body parameters
Name Description
insertPackingOptionRequest

Responses


insertPlacementOption

Store a placement option


/api/v2/inbound-plan/{inbound_plan_id}/placement-options/{placement_option_id}

Usage and SDK Samples

curl -X PUT \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/v2/inbound-plan/{inbound_plan_id}/placement-options/{placement_option_id}" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2InboundPlanApi;

import java.io.File;
import java.util.*;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearer_auth
        HttpBearerAuth bearer_auth = (HttpBearerAuth) defaultClient.getAuthentication("bearer_auth");
        bearer_auth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String placementOptionId = placementOptionId_example; // String | 
        SpapiPlacementOption spapiPlacementOption = ; // SpapiPlacementOption | 

        try {
            insertPlacementOption_200_response result = apiInstance.insertPlacementOption(inboundPlanId, placementOptionId, spapiPlacementOption);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#insertPlacementOption");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String placementOptionId = new String(); // String | 
final SpapiPlacementOption spapiPlacementOption = new SpapiPlacementOption(); // SpapiPlacementOption | 

try {
    final result = await api_instance.insertPlacementOption(inboundPlanId, placementOptionId, spapiPlacementOption);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->insertPlacementOption: $e\n');
}

import org.openapitools.client.api.V2InboundPlanApi;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String placementOptionId = placementOptionId_example; // String | 
        SpapiPlacementOption spapiPlacementOption = ; // SpapiPlacementOption | 

        try {
            insertPlacementOption_200_response result = apiInstance.insertPlacementOption(inboundPlanId, placementOptionId, spapiPlacementOption);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#insertPlacementOption");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearer_auth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
V2InboundPlanApi *apiInstance = [[V2InboundPlanApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *placementOptionId = placementOptionId_example; //  (default to null)
SpapiPlacementOption *spapiPlacementOption = ; //  (optional)

[apiInstance insertPlacementOptionWith:inboundPlanId
    placementOptionId:placementOptionId
    spapiPlacementOption:spapiPlacementOption
              completionHandler: ^(insertPlacementOption_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearer_auth
var bearer_auth = defaultClient.authentications['bearer_auth'];
bearer_auth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ScanPowerApi.V2InboundPlanApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var placementOptionId = placementOptionId_example; // {String} 
var opts = {
  'spapiPlacementOption':  // {SpapiPlacementOption} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.insertPlacementOption(inboundPlanId, placementOptionId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class insertPlacementOptionExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearer_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new V2InboundPlanApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var placementOptionId = placementOptionId_example;  // String |  (default to null)
            var spapiPlacementOption = new SpapiPlacementOption(); // SpapiPlacementOption |  (optional) 

            try {
                insertPlacementOption_200_response result = apiInstance.insertPlacementOption(inboundPlanId, placementOptionId, spapiPlacementOption);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2InboundPlanApi.insertPlacementOption: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer (JWT) access token for authorization: bearer_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2InboundPlanApi();
$inboundPlanId = inboundPlanId_example; // String | 
$placementOptionId = placementOptionId_example; // String | 
$spapiPlacementOption = ; // SpapiPlacementOption | 

try {
    $result = $api_instance->insertPlacementOption($inboundPlanId, $placementOptionId, $spapiPlacementOption);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2InboundPlanApi->insertPlacementOption: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2InboundPlanApi;

# Configure Bearer (JWT) access token for authorization: bearer_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2InboundPlanApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $placementOptionId = placementOptionId_example; # String | 
my $spapiPlacementOption = WWW::OPenAPIClient::Object::SpapiPlacementOption->new(); # SpapiPlacementOption | 

eval {
    my $result = $api_instance->insertPlacementOption(inboundPlanId => $inboundPlanId, placementOptionId => $placementOptionId, spapiPlacementOption => $spapiPlacementOption);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2InboundPlanApi->insertPlacementOption: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: bearer_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.V2InboundPlanApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
placementOptionId = placementOptionId_example # String |  (default to null)
spapiPlacementOption =  # SpapiPlacementOption |  (optional)

try:
    api_response = api_instance.insert_placement_option(inboundPlanId, placementOptionId, spapiPlacementOption=spapiPlacementOption)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2InboundPlanApi->insertPlacementOption: %s\n" % e)
extern crate V2InboundPlanApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let placementOptionId = placementOptionId_example; // String
    let spapiPlacementOption = ; // SpapiPlacementOption

    let mut context = V2InboundPlanApi::Context::default();
    let result = client.insertPlacementOption(inboundPlanId, placementOptionId, spapiPlacementOption, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
inbound_plan_id*
String
Required
placement_option_id*
String
Required
Body parameters
Name Description
spapiPlacementOption

Responses


insertShipment

Insert an AZ shipment into our database


/api/v2/inbound-plan/{inbound_plan_id}/shipments/{shipment_id}

Usage and SDK Samples

curl -X PUT \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/v2/inbound-plan/{inbound_plan_id}/shipments/{shipment_id}" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2InboundPlanApi;

import java.io.File;
import java.util.*;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearer_auth
        HttpBearerAuth bearer_auth = (HttpBearerAuth) defaultClient.getAuthentication("bearer_auth");
        bearer_auth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        V2ShipmentInput v2ShipmentInput = ; // V2ShipmentInput | 

        try {
            insertShipment_200_response result = apiInstance.insertShipment(inboundPlanId, shipmentId, v2ShipmentInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#insertShipment");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String shipmentId = new String(); // String | 
final V2ShipmentInput v2ShipmentInput = new V2ShipmentInput(); // V2ShipmentInput | 

try {
    final result = await api_instance.insertShipment(inboundPlanId, shipmentId, v2ShipmentInput);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->insertShipment: $e\n');
}

import org.openapitools.client.api.V2InboundPlanApi;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        V2ShipmentInput v2ShipmentInput = ; // V2ShipmentInput | 

        try {
            insertShipment_200_response result = apiInstance.insertShipment(inboundPlanId, shipmentId, v2ShipmentInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#insertShipment");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearer_auth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
V2InboundPlanApi *apiInstance = [[V2InboundPlanApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *shipmentId = shipmentId_example; //  (default to null)
V2ShipmentInput *v2ShipmentInput = ; //  (optional)

[apiInstance insertShipmentWith:inboundPlanId
    shipmentId:shipmentId
    v2ShipmentInput:v2ShipmentInput
              completionHandler: ^(insertShipment_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearer_auth
var bearer_auth = defaultClient.authentications['bearer_auth'];
bearer_auth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ScanPowerApi.V2InboundPlanApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var shipmentId = shipmentId_example; // {String} 
var opts = {
  'v2ShipmentInput':  // {V2ShipmentInput} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.insertShipment(inboundPlanId, shipmentId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class insertShipmentExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearer_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new V2InboundPlanApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var shipmentId = shipmentId_example;  // String |  (default to null)
            var v2ShipmentInput = new V2ShipmentInput(); // V2ShipmentInput |  (optional) 

            try {
                insertShipment_200_response result = apiInstance.insertShipment(inboundPlanId, shipmentId, v2ShipmentInput);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2InboundPlanApi.insertShipment: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer (JWT) access token for authorization: bearer_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2InboundPlanApi();
$inboundPlanId = inboundPlanId_example; // String | 
$shipmentId = shipmentId_example; // String | 
$v2ShipmentInput = ; // V2ShipmentInput | 

try {
    $result = $api_instance->insertShipment($inboundPlanId, $shipmentId, $v2ShipmentInput);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2InboundPlanApi->insertShipment: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2InboundPlanApi;

# Configure Bearer (JWT) access token for authorization: bearer_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2InboundPlanApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $shipmentId = shipmentId_example; # String | 
my $v2ShipmentInput = WWW::OPenAPIClient::Object::V2ShipmentInput->new(); # V2ShipmentInput | 

eval {
    my $result = $api_instance->insertShipment(inboundPlanId => $inboundPlanId, shipmentId => $shipmentId, v2ShipmentInput => $v2ShipmentInput);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2InboundPlanApi->insertShipment: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: bearer_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.V2InboundPlanApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
shipmentId = shipmentId_example # String |  (default to null)
v2ShipmentInput =  # V2ShipmentInput |  (optional)

try:
    api_response = api_instance.insert_shipment(inboundPlanId, shipmentId, v2ShipmentInput=v2ShipmentInput)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2InboundPlanApi->insertShipment: %s\n" % e)
extern crate V2InboundPlanApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let shipmentId = shipmentId_example; // String
    let v2ShipmentInput = ; // V2ShipmentInput

    let mut context = V2InboundPlanApi::Context::default();
    let result = client.insertShipment(inboundPlanId, shipmentId, v2ShipmentInput, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
inbound_plan_id*
String
Required
shipment_id*
String
Required
Body parameters
Name Description
v2ShipmentInput

Responses


insertTransportationOption

Load the given transportation option by id


/api/v2/inbound-plan/{inbound_plan_id}/placement-options/{placement_option_id}/transportation-options/{transportation_option_id}

Usage and SDK Samples

curl -X PUT \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/v2/inbound-plan/{inbound_plan_id}/placement-options/{placement_option_id}/transportation-options/{transportation_option_id}" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2InboundPlanApi;

import java.io.File;
import java.util.*;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearer_auth
        HttpBearerAuth bearer_auth = (HttpBearerAuth) defaultClient.getAuthentication("bearer_auth");
        bearer_auth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String placementOptionId = placementOptionId_example; // String | 
        String transportationOptionId = transportationOptionId_example; // String | 
        V2TransportationOptionInput v2TransportationOptionInput = ; // V2TransportationOptionInput | 

        try {
            selectTransportationOption_200_response result = apiInstance.insertTransportationOption(inboundPlanId, placementOptionId, transportationOptionId, v2TransportationOptionInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#insertTransportationOption");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String placementOptionId = new String(); // String | 
final String transportationOptionId = new String(); // String | 
final V2TransportationOptionInput v2TransportationOptionInput = new V2TransportationOptionInput(); // V2TransportationOptionInput | 

try {
    final result = await api_instance.insertTransportationOption(inboundPlanId, placementOptionId, transportationOptionId, v2TransportationOptionInput);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->insertTransportationOption: $e\n');
}

import org.openapitools.client.api.V2InboundPlanApi;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String placementOptionId = placementOptionId_example; // String | 
        String transportationOptionId = transportationOptionId_example; // String | 
        V2TransportationOptionInput v2TransportationOptionInput = ; // V2TransportationOptionInput | 

        try {
            selectTransportationOption_200_response result = apiInstance.insertTransportationOption(inboundPlanId, placementOptionId, transportationOptionId, v2TransportationOptionInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#insertTransportationOption");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearer_auth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
V2InboundPlanApi *apiInstance = [[V2InboundPlanApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *placementOptionId = placementOptionId_example; //  (default to null)
String *transportationOptionId = transportationOptionId_example; //  (default to null)
V2TransportationOptionInput *v2TransportationOptionInput = ; //  (optional)

[apiInstance insertTransportationOptionWith:inboundPlanId
    placementOptionId:placementOptionId
    transportationOptionId:transportationOptionId
    v2TransportationOptionInput:v2TransportationOptionInput
              completionHandler: ^(selectTransportationOption_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearer_auth
var bearer_auth = defaultClient.authentications['bearer_auth'];
bearer_auth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ScanPowerApi.V2InboundPlanApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var placementOptionId = placementOptionId_example; // {String} 
var transportationOptionId = transportationOptionId_example; // {String} 
var opts = {
  'v2TransportationOptionInput':  // {V2TransportationOptionInput} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.insertTransportationOption(inboundPlanId, placementOptionId, transportationOptionId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class insertTransportationOptionExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearer_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new V2InboundPlanApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var placementOptionId = placementOptionId_example;  // String |  (default to null)
            var transportationOptionId = transportationOptionId_example;  // String |  (default to null)
            var v2TransportationOptionInput = new V2TransportationOptionInput(); // V2TransportationOptionInput |  (optional) 

            try {
                selectTransportationOption_200_response result = apiInstance.insertTransportationOption(inboundPlanId, placementOptionId, transportationOptionId, v2TransportationOptionInput);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2InboundPlanApi.insertTransportationOption: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer (JWT) access token for authorization: bearer_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2InboundPlanApi();
$inboundPlanId = inboundPlanId_example; // String | 
$placementOptionId = placementOptionId_example; // String | 
$transportationOptionId = transportationOptionId_example; // String | 
$v2TransportationOptionInput = ; // V2TransportationOptionInput | 

try {
    $result = $api_instance->insertTransportationOption($inboundPlanId, $placementOptionId, $transportationOptionId, $v2TransportationOptionInput);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2InboundPlanApi->insertTransportationOption: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2InboundPlanApi;

# Configure Bearer (JWT) access token for authorization: bearer_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2InboundPlanApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $placementOptionId = placementOptionId_example; # String | 
my $transportationOptionId = transportationOptionId_example; # String | 
my $v2TransportationOptionInput = WWW::OPenAPIClient::Object::V2TransportationOptionInput->new(); # V2TransportationOptionInput | 

eval {
    my $result = $api_instance->insertTransportationOption(inboundPlanId => $inboundPlanId, placementOptionId => $placementOptionId, transportationOptionId => $transportationOptionId, v2TransportationOptionInput => $v2TransportationOptionInput);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2InboundPlanApi->insertTransportationOption: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: bearer_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.V2InboundPlanApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
placementOptionId = placementOptionId_example # String |  (default to null)
transportationOptionId = transportationOptionId_example # String |  (default to null)
v2TransportationOptionInput =  # V2TransportationOptionInput |  (optional)

try:
    api_response = api_instance.insert_transportation_option(inboundPlanId, placementOptionId, transportationOptionId, v2TransportationOptionInput=v2TransportationOptionInput)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2InboundPlanApi->insertTransportationOption: %s\n" % e)
extern crate V2InboundPlanApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let placementOptionId = placementOptionId_example; // String
    let transportationOptionId = transportationOptionId_example; // String
    let v2TransportationOptionInput = ; // V2TransportationOptionInput

    let mut context = V2InboundPlanApi::Context::default();
    let result = client.insertTransportationOption(inboundPlanId, placementOptionId, transportationOptionId, v2TransportationOptionInput, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
inbound_plan_id*
String
Required
placement_option_id*
String
Required
transportation_option_id*
String
Required
Body parameters
Name Description
v2TransportationOptionInput

Responses


selectDeliveryWindowOption

Get an AZ delivery window option stored in our database


/api/v2/inbound-plan/{inbound_plan_id}/shipments/{shipment_id}/delivery-window-options/{delivery_window_option_id}

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/v2/inbound-plan/{inbound_plan_id}/shipments/{shipment_id}/delivery-window-options/{delivery_window_option_id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2InboundPlanApi;

import java.io.File;
import java.util.*;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearer_auth
        HttpBearerAuth bearer_auth = (HttpBearerAuth) defaultClient.getAuthentication("bearer_auth");
        bearer_auth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        String deliveryWindowOptionId = deliveryWindowOptionId_example; // String | 

        try {
            selectDeliveryWindowOption_200_response result = apiInstance.selectDeliveryWindowOption(inboundPlanId, shipmentId, deliveryWindowOptionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#selectDeliveryWindowOption");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String shipmentId = new String(); // String | 
final String deliveryWindowOptionId = new String(); // String | 

try {
    final result = await api_instance.selectDeliveryWindowOption(inboundPlanId, shipmentId, deliveryWindowOptionId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->selectDeliveryWindowOption: $e\n');
}

import org.openapitools.client.api.V2InboundPlanApi;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        String deliveryWindowOptionId = deliveryWindowOptionId_example; // String | 

        try {
            selectDeliveryWindowOption_200_response result = apiInstance.selectDeliveryWindowOption(inboundPlanId, shipmentId, deliveryWindowOptionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#selectDeliveryWindowOption");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearer_auth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
V2InboundPlanApi *apiInstance = [[V2InboundPlanApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *shipmentId = shipmentId_example; //  (default to null)
String *deliveryWindowOptionId = deliveryWindowOptionId_example; //  (default to null)

[apiInstance selectDeliveryWindowOptionWith:inboundPlanId
    shipmentId:shipmentId
    deliveryWindowOptionId:deliveryWindowOptionId
              completionHandler: ^(selectDeliveryWindowOption_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearer_auth
var bearer_auth = defaultClient.authentications['bearer_auth'];
bearer_auth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ScanPowerApi.V2InboundPlanApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var shipmentId = shipmentId_example; // {String} 
var deliveryWindowOptionId = deliveryWindowOptionId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.selectDeliveryWindowOption(inboundPlanId, shipmentId, deliveryWindowOptionId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class selectDeliveryWindowOptionExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearer_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new V2InboundPlanApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var shipmentId = shipmentId_example;  // String |  (default to null)
            var deliveryWindowOptionId = deliveryWindowOptionId_example;  // String |  (default to null)

            try {
                selectDeliveryWindowOption_200_response result = apiInstance.selectDeliveryWindowOption(inboundPlanId, shipmentId, deliveryWindowOptionId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2InboundPlanApi.selectDeliveryWindowOption: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer (JWT) access token for authorization: bearer_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2InboundPlanApi();
$inboundPlanId = inboundPlanId_example; // String | 
$shipmentId = shipmentId_example; // String | 
$deliveryWindowOptionId = deliveryWindowOptionId_example; // String | 

try {
    $result = $api_instance->selectDeliveryWindowOption($inboundPlanId, $shipmentId, $deliveryWindowOptionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2InboundPlanApi->selectDeliveryWindowOption: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2InboundPlanApi;

# Configure Bearer (JWT) access token for authorization: bearer_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2InboundPlanApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $shipmentId = shipmentId_example; # String | 
my $deliveryWindowOptionId = deliveryWindowOptionId_example; # String | 

eval {
    my $result = $api_instance->selectDeliveryWindowOption(inboundPlanId => $inboundPlanId, shipmentId => $shipmentId, deliveryWindowOptionId => $deliveryWindowOptionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2InboundPlanApi->selectDeliveryWindowOption: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: bearer_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.V2InboundPlanApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
shipmentId = shipmentId_example # String |  (default to null)
deliveryWindowOptionId = deliveryWindowOptionId_example # String |  (default to null)

try:
    api_response = api_instance.select_delivery_window_option(inboundPlanId, shipmentId, deliveryWindowOptionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2InboundPlanApi->selectDeliveryWindowOption: %s\n" % e)
extern crate V2InboundPlanApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let shipmentId = shipmentId_example; // String
    let deliveryWindowOptionId = deliveryWindowOptionId_example; // String

    let mut context = V2InboundPlanApi::Context::default();
    let result = client.selectDeliveryWindowOption(inboundPlanId, shipmentId, deliveryWindowOptionId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
inbound_plan_id*
String
Required
shipment_id*
String
Required
delivery_window_option_id*
String
Required

Responses


selectDeliveryWindowOptions

Get AZ delivery window options stored in our database


/api/v2/inbound-plan/{inbound_plan_id}/shipments/:shipment_id/delivery-window-options

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/v2/inbound-plan/{inbound_plan_id}/shipments/:shipment_id/delivery-window-options"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2InboundPlanApi;

import java.io.File;
import java.util.*;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearer_auth
        HttpBearerAuth bearer_auth = (HttpBearerAuth) defaultClient.getAuthentication("bearer_auth");
        bearer_auth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 

        try {
            selectDeliveryWindowOptions_200_response result = apiInstance.selectDeliveryWindowOptions(inboundPlanId, shipmentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#selectDeliveryWindowOptions");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String shipmentId = new String(); // String | 

try {
    final result = await api_instance.selectDeliveryWindowOptions(inboundPlanId, shipmentId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->selectDeliveryWindowOptions: $e\n');
}

import org.openapitools.client.api.V2InboundPlanApi;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 

        try {
            selectDeliveryWindowOptions_200_response result = apiInstance.selectDeliveryWindowOptions(inboundPlanId, shipmentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#selectDeliveryWindowOptions");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearer_auth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
V2InboundPlanApi *apiInstance = [[V2InboundPlanApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *shipmentId = shipmentId_example; //  (default to null)

[apiInstance selectDeliveryWindowOptionsWith:inboundPlanId
    shipmentId:shipmentId
              completionHandler: ^(selectDeliveryWindowOptions_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearer_auth
var bearer_auth = defaultClient.authentications['bearer_auth'];
bearer_auth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ScanPowerApi.V2InboundPlanApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var shipmentId = shipmentId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.selectDeliveryWindowOptions(inboundPlanId, shipmentId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class selectDeliveryWindowOptionsExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearer_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new V2InboundPlanApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var shipmentId = shipmentId_example;  // String |  (default to null)

            try {
                selectDeliveryWindowOptions_200_response result = apiInstance.selectDeliveryWindowOptions(inboundPlanId, shipmentId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2InboundPlanApi.selectDeliveryWindowOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer (JWT) access token for authorization: bearer_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2InboundPlanApi();
$inboundPlanId = inboundPlanId_example; // String | 
$shipmentId = shipmentId_example; // String | 

try {
    $result = $api_instance->selectDeliveryWindowOptions($inboundPlanId, $shipmentId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2InboundPlanApi->selectDeliveryWindowOptions: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2InboundPlanApi;

# Configure Bearer (JWT) access token for authorization: bearer_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2InboundPlanApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $shipmentId = shipmentId_example; # String | 

eval {
    my $result = $api_instance->selectDeliveryWindowOptions(inboundPlanId => $inboundPlanId, shipmentId => $shipmentId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2InboundPlanApi->selectDeliveryWindowOptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: bearer_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.V2InboundPlanApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
shipmentId = shipmentId_example # String |  (default to null)

try:
    api_response = api_instance.select_delivery_window_options(inboundPlanId, shipmentId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2InboundPlanApi->selectDeliveryWindowOptions: %s\n" % e)
extern crate V2InboundPlanApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let shipmentId = shipmentId_example; // String

    let mut context = V2InboundPlanApi::Context::default();
    let result = client.selectDeliveryWindowOptions(inboundPlanId, shipmentId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
inbound_plan_id*
String
Required
shipment_id*
String
Required

Responses


selectInboundPlan

Get an inbound plan by id


/api/v2/inbound-plan/{inbound_plan_id}

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/v2/inbound-plan/{inbound_plan_id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2InboundPlanApi;

import java.io.File;
import java.util.*;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearer_auth
        HttpBearerAuth bearer_auth = (HttpBearerAuth) defaultClient.getAuthentication("bearer_auth");
        bearer_auth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 

        try {
            selectInboundPlan_200_response result = apiInstance.selectInboundPlan(inboundPlanId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#selectInboundPlan");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 

try {
    final result = await api_instance.selectInboundPlan(inboundPlanId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->selectInboundPlan: $e\n');
}

import org.openapitools.client.api.V2InboundPlanApi;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 

        try {
            selectInboundPlan_200_response result = apiInstance.selectInboundPlan(inboundPlanId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#selectInboundPlan");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearer_auth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
V2InboundPlanApi *apiInstance = [[V2InboundPlanApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)

[apiInstance selectInboundPlanWith:inboundPlanId
              completionHandler: ^(selectInboundPlan_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearer_auth
var bearer_auth = defaultClient.authentications['bearer_auth'];
bearer_auth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ScanPowerApi.V2InboundPlanApi()
var inboundPlanId = inboundPlanId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.selectInboundPlan(inboundPlanId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class selectInboundPlanExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearer_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new V2InboundPlanApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)

            try {
                selectInboundPlan_200_response result = apiInstance.selectInboundPlan(inboundPlanId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2InboundPlanApi.selectInboundPlan: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer (JWT) access token for authorization: bearer_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2InboundPlanApi();
$inboundPlanId = inboundPlanId_example; // String | 

try {
    $result = $api_instance->selectInboundPlan($inboundPlanId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2InboundPlanApi->selectInboundPlan: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2InboundPlanApi;

# Configure Bearer (JWT) access token for authorization: bearer_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2InboundPlanApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 

eval {
    my $result = $api_instance->selectInboundPlan(inboundPlanId => $inboundPlanId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2InboundPlanApi->selectInboundPlan: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: bearer_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.V2InboundPlanApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)

try:
    api_response = api_instance.select_inbound_plan(inboundPlanId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2InboundPlanApi->selectInboundPlan: %s\n" % e)
extern crate V2InboundPlanApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String

    let mut context = V2InboundPlanApi::Context::default();
    let result = client.selectInboundPlan(inboundPlanId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
inbound_plan_id*
String
Required

Responses


selectInboundPlans

Get the inbound plan(s) for a batch or shipment


/api/v2/inbound-plan/

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/v2/inbound-plan/?v1_batch_id=v1BatchId_example&v2_batch_id=v2BatchId_example&shipment_id=shipmentId_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2InboundPlanApi;

import java.io.File;
import java.util.*;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearer_auth
        HttpBearerAuth bearer_auth = (HttpBearerAuth) defaultClient.getAuthentication("bearer_auth");
        bearer_auth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String v1BatchId = v1BatchId_example; // String | 
        String v2BatchId = v2BatchId_example; // String | 
        String shipmentId = shipmentId_example; // String | 

        try {
            selectInboundPlans_200_response result = apiInstance.selectInboundPlans(v1BatchId, v2BatchId, shipmentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#selectInboundPlans");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String v1BatchId = new String(); // String | 
final String v2BatchId = new String(); // String | 
final String shipmentId = new String(); // String | 

try {
    final result = await api_instance.selectInboundPlans(v1BatchId, v2BatchId, shipmentId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->selectInboundPlans: $e\n');
}

import org.openapitools.client.api.V2InboundPlanApi;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String v1BatchId = v1BatchId_example; // String | 
        String v2BatchId = v2BatchId_example; // String | 
        String shipmentId = shipmentId_example; // String | 

        try {
            selectInboundPlans_200_response result = apiInstance.selectInboundPlans(v1BatchId, v2BatchId, shipmentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#selectInboundPlans");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearer_auth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
V2InboundPlanApi *apiInstance = [[V2InboundPlanApi alloc] init];
String *v1BatchId = v1BatchId_example; //  (optional) (default to null)
String *v2BatchId = v2BatchId_example; //  (optional) (default to null)
String *shipmentId = shipmentId_example; //  (optional) (default to null)

[apiInstance selectInboundPlansWith:v1BatchId
    v2BatchId:v2BatchId
    shipmentId:shipmentId
              completionHandler: ^(selectInboundPlans_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearer_auth
var bearer_auth = defaultClient.authentications['bearer_auth'];
bearer_auth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ScanPowerApi.V2InboundPlanApi()
var opts = {
  'v1BatchId': v1BatchId_example, // {String} 
  'v2BatchId': v2BatchId_example, // {String} 
  'shipmentId': shipmentId_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.selectInboundPlans(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class selectInboundPlansExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearer_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new V2InboundPlanApi();
            var v1BatchId = v1BatchId_example;  // String |  (optional)  (default to null)
            var v2BatchId = v2BatchId_example;  // String |  (optional)  (default to null)
            var shipmentId = shipmentId_example;  // String |  (optional)  (default to null)

            try {
                selectInboundPlans_200_response result = apiInstance.selectInboundPlans(v1BatchId, v2BatchId, shipmentId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2InboundPlanApi.selectInboundPlans: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer (JWT) access token for authorization: bearer_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2InboundPlanApi();
$v1BatchId = v1BatchId_example; // String | 
$v2BatchId = v2BatchId_example; // String | 
$shipmentId = shipmentId_example; // String | 

try {
    $result = $api_instance->selectInboundPlans($v1BatchId, $v2BatchId, $shipmentId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2InboundPlanApi->selectInboundPlans: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2InboundPlanApi;

# Configure Bearer (JWT) access token for authorization: bearer_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2InboundPlanApi->new();
my $v1BatchId = v1BatchId_example; # String | 
my $v2BatchId = v2BatchId_example; # String | 
my $shipmentId = shipmentId_example; # String | 

eval {
    my $result = $api_instance->selectInboundPlans(v1BatchId => $v1BatchId, v2BatchId => $v2BatchId, shipmentId => $shipmentId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2InboundPlanApi->selectInboundPlans: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: bearer_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.V2InboundPlanApi()
v1BatchId = v1BatchId_example # String |  (optional) (default to null)
v2BatchId = v2BatchId_example # String |  (optional) (default to null)
shipmentId = shipmentId_example # String |  (optional) (default to null)

try:
    api_response = api_instance.select_inbound_plans(v1BatchId=v1BatchId, v2BatchId=v2BatchId, shipmentId=shipmentId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2InboundPlanApi->selectInboundPlans: %s\n" % e)
extern crate V2InboundPlanApi;

pub fn main() {
    let v1BatchId = v1BatchId_example; // String
    let v2BatchId = v2BatchId_example; // String
    let shipmentId = shipmentId_example; // String

    let mut context = V2InboundPlanApi::Context::default();
    let result = client.selectInboundPlans(v1BatchId, v2BatchId, shipmentId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
v1_batch_id
String
v2_batch_id
String
shipment_id
String

Responses


selectPackingOptions

Load the packing options for a given inbound plan


/api/v2/inbound-plan/{inbound_plan_id}/packing-options

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/v2/inbound-plan/{inbound_plan_id}/packing-options"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2InboundPlanApi;

import java.io.File;
import java.util.*;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearer_auth
        HttpBearerAuth bearer_auth = (HttpBearerAuth) defaultClient.getAuthentication("bearer_auth");
        bearer_auth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 

        try {
            selectPackingOptions_200_response result = apiInstance.selectPackingOptions(inboundPlanId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#selectPackingOptions");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 

try {
    final result = await api_instance.selectPackingOptions(inboundPlanId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->selectPackingOptions: $e\n');
}

import org.openapitools.client.api.V2InboundPlanApi;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 

        try {
            selectPackingOptions_200_response result = apiInstance.selectPackingOptions(inboundPlanId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#selectPackingOptions");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearer_auth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
V2InboundPlanApi *apiInstance = [[V2InboundPlanApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)

[apiInstance selectPackingOptionsWith:inboundPlanId
              completionHandler: ^(selectPackingOptions_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearer_auth
var bearer_auth = defaultClient.authentications['bearer_auth'];
bearer_auth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ScanPowerApi.V2InboundPlanApi()
var inboundPlanId = inboundPlanId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.selectPackingOptions(inboundPlanId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class selectPackingOptionsExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearer_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new V2InboundPlanApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)

            try {
                selectPackingOptions_200_response result = apiInstance.selectPackingOptions(inboundPlanId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2InboundPlanApi.selectPackingOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer (JWT) access token for authorization: bearer_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2InboundPlanApi();
$inboundPlanId = inboundPlanId_example; // String | 

try {
    $result = $api_instance->selectPackingOptions($inboundPlanId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2InboundPlanApi->selectPackingOptions: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2InboundPlanApi;

# Configure Bearer (JWT) access token for authorization: bearer_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2InboundPlanApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 

eval {
    my $result = $api_instance->selectPackingOptions(inboundPlanId => $inboundPlanId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2InboundPlanApi->selectPackingOptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: bearer_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.V2InboundPlanApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)

try:
    api_response = api_instance.select_packing_options(inboundPlanId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2InboundPlanApi->selectPackingOptions: %s\n" % e)
extern crate V2InboundPlanApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String

    let mut context = V2InboundPlanApi::Context::default();
    let result = client.selectPackingOptions(inboundPlanId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
inbound_plan_id*
String
Required

Responses


selectPlacementOptions

Load the placement options for a given inbound plan


/api/v2/inbound-plan/{inbound_plan_id}/placement-options

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/v2/inbound-plan/{inbound_plan_id}/placement-options"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2InboundPlanApi;

import java.io.File;
import java.util.*;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearer_auth
        HttpBearerAuth bearer_auth = (HttpBearerAuth) defaultClient.getAuthentication("bearer_auth");
        bearer_auth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 

        try {
            selectPlacementOptions_200_response result = apiInstance.selectPlacementOptions(inboundPlanId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#selectPlacementOptions");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 

try {
    final result = await api_instance.selectPlacementOptions(inboundPlanId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->selectPlacementOptions: $e\n');
}

import org.openapitools.client.api.V2InboundPlanApi;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 

        try {
            selectPlacementOptions_200_response result = apiInstance.selectPlacementOptions(inboundPlanId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#selectPlacementOptions");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearer_auth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
V2InboundPlanApi *apiInstance = [[V2InboundPlanApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)

[apiInstance selectPlacementOptionsWith:inboundPlanId
              completionHandler: ^(selectPlacementOptions_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearer_auth
var bearer_auth = defaultClient.authentications['bearer_auth'];
bearer_auth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ScanPowerApi.V2InboundPlanApi()
var inboundPlanId = inboundPlanId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.selectPlacementOptions(inboundPlanId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class selectPlacementOptionsExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearer_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new V2InboundPlanApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)

            try {
                selectPlacementOptions_200_response result = apiInstance.selectPlacementOptions(inboundPlanId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2InboundPlanApi.selectPlacementOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer (JWT) access token for authorization: bearer_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2InboundPlanApi();
$inboundPlanId = inboundPlanId_example; // String | 

try {
    $result = $api_instance->selectPlacementOptions($inboundPlanId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2InboundPlanApi->selectPlacementOptions: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2InboundPlanApi;

# Configure Bearer (JWT) access token for authorization: bearer_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2InboundPlanApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 

eval {
    my $result = $api_instance->selectPlacementOptions(inboundPlanId => $inboundPlanId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2InboundPlanApi->selectPlacementOptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: bearer_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.V2InboundPlanApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)

try:
    api_response = api_instance.select_placement_options(inboundPlanId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2InboundPlanApi->selectPlacementOptions: %s\n" % e)
extern crate V2InboundPlanApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String

    let mut context = V2InboundPlanApi::Context::default();
    let result = client.selectPlacementOptions(inboundPlanId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
inbound_plan_id*
String
Required

Responses


selectShipments

Get AZ shipments stored in our database


/api/v2/inbound-plan/{inbound_plan_id}/shipments

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/v2/inbound-plan/{inbound_plan_id}/shipments"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2InboundPlanApi;

import java.io.File;
import java.util.*;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearer_auth
        HttpBearerAuth bearer_auth = (HttpBearerAuth) defaultClient.getAuthentication("bearer_auth");
        bearer_auth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 

        try {
            selectShipments_200_response result = apiInstance.selectShipments(inboundPlanId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#selectShipments");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 

try {
    final result = await api_instance.selectShipments(inboundPlanId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->selectShipments: $e\n');
}

import org.openapitools.client.api.V2InboundPlanApi;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 

        try {
            selectShipments_200_response result = apiInstance.selectShipments(inboundPlanId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#selectShipments");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearer_auth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
V2InboundPlanApi *apiInstance = [[V2InboundPlanApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)

[apiInstance selectShipmentsWith:inboundPlanId
              completionHandler: ^(selectShipments_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearer_auth
var bearer_auth = defaultClient.authentications['bearer_auth'];
bearer_auth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ScanPowerApi.V2InboundPlanApi()
var inboundPlanId = inboundPlanId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.selectShipments(inboundPlanId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class selectShipmentsExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearer_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new V2InboundPlanApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)

            try {
                selectShipments_200_response result = apiInstance.selectShipments(inboundPlanId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2InboundPlanApi.selectShipments: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer (JWT) access token for authorization: bearer_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2InboundPlanApi();
$inboundPlanId = inboundPlanId_example; // String | 

try {
    $result = $api_instance->selectShipments($inboundPlanId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2InboundPlanApi->selectShipments: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2InboundPlanApi;

# Configure Bearer (JWT) access token for authorization: bearer_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2InboundPlanApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 

eval {
    my $result = $api_instance->selectShipments(inboundPlanId => $inboundPlanId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2InboundPlanApi->selectShipments: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: bearer_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.V2InboundPlanApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)

try:
    api_response = api_instance.select_shipments(inboundPlanId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2InboundPlanApi->selectShipments: %s\n" % e)
extern crate V2InboundPlanApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String

    let mut context = V2InboundPlanApi::Context::default();
    let result = client.selectShipments(inboundPlanId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
inbound_plan_id*
String
Required

Responses


selectTransportationOption

Load the given transportation option by id


/api/v2/inbound-plan/{inbound_plan_id}/placement-options/{placement_option_id}/transportation-options/{transportation_option_id}

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/v2/inbound-plan/{inbound_plan_id}/placement-options/{placement_option_id}/transportation-options/{transportation_option_id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2InboundPlanApi;

import java.io.File;
import java.util.*;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearer_auth
        HttpBearerAuth bearer_auth = (HttpBearerAuth) defaultClient.getAuthentication("bearer_auth");
        bearer_auth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String placementOptionId = placementOptionId_example; // String | 
        String transportationOptionId = transportationOptionId_example; // String | 

        try {
            selectTransportationOption_200_response result = apiInstance.selectTransportationOption(inboundPlanId, placementOptionId, transportationOptionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#selectTransportationOption");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String placementOptionId = new String(); // String | 
final String transportationOptionId = new String(); // String | 

try {
    final result = await api_instance.selectTransportationOption(inboundPlanId, placementOptionId, transportationOptionId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->selectTransportationOption: $e\n');
}

import org.openapitools.client.api.V2InboundPlanApi;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String placementOptionId = placementOptionId_example; // String | 
        String transportationOptionId = transportationOptionId_example; // String | 

        try {
            selectTransportationOption_200_response result = apiInstance.selectTransportationOption(inboundPlanId, placementOptionId, transportationOptionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#selectTransportationOption");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearer_auth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
V2InboundPlanApi *apiInstance = [[V2InboundPlanApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *placementOptionId = placementOptionId_example; //  (default to null)
String *transportationOptionId = transportationOptionId_example; //  (default to null)

[apiInstance selectTransportationOptionWith:inboundPlanId
    placementOptionId:placementOptionId
    transportationOptionId:transportationOptionId
              completionHandler: ^(selectTransportationOption_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearer_auth
var bearer_auth = defaultClient.authentications['bearer_auth'];
bearer_auth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ScanPowerApi.V2InboundPlanApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var placementOptionId = placementOptionId_example; // {String} 
var transportationOptionId = transportationOptionId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.selectTransportationOption(inboundPlanId, placementOptionId, transportationOptionId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class selectTransportationOptionExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearer_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new V2InboundPlanApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var placementOptionId = placementOptionId_example;  // String |  (default to null)
            var transportationOptionId = transportationOptionId_example;  // String |  (default to null)

            try {
                selectTransportationOption_200_response result = apiInstance.selectTransportationOption(inboundPlanId, placementOptionId, transportationOptionId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2InboundPlanApi.selectTransportationOption: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer (JWT) access token for authorization: bearer_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2InboundPlanApi();
$inboundPlanId = inboundPlanId_example; // String | 
$placementOptionId = placementOptionId_example; // String | 
$transportationOptionId = transportationOptionId_example; // String | 

try {
    $result = $api_instance->selectTransportationOption($inboundPlanId, $placementOptionId, $transportationOptionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2InboundPlanApi->selectTransportationOption: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2InboundPlanApi;

# Configure Bearer (JWT) access token for authorization: bearer_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2InboundPlanApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $placementOptionId = placementOptionId_example; # String | 
my $transportationOptionId = transportationOptionId_example; # String | 

eval {
    my $result = $api_instance->selectTransportationOption(inboundPlanId => $inboundPlanId, placementOptionId => $placementOptionId, transportationOptionId => $transportationOptionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2InboundPlanApi->selectTransportationOption: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: bearer_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.V2InboundPlanApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
placementOptionId = placementOptionId_example # String |  (default to null)
transportationOptionId = transportationOptionId_example # String |  (default to null)

try:
    api_response = api_instance.select_transportation_option(inboundPlanId, placementOptionId, transportationOptionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2InboundPlanApi->selectTransportationOption: %s\n" % e)
extern crate V2InboundPlanApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let placementOptionId = placementOptionId_example; // String
    let transportationOptionId = transportationOptionId_example; // String

    let mut context = V2InboundPlanApi::Context::default();
    let result = client.selectTransportationOption(inboundPlanId, placementOptionId, transportationOptionId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
inbound_plan_id*
String
Required
placement_option_id*
String
Required
transportation_option_id*
String
Required

Responses


selectTransportationOptions

Load the transportation options for a given inbound plan and placement option


/api/v2/inbound-plan/{inbound_plan_id}/placement-options/{placement_option_id}/transportation-options

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/v2/inbound-plan/{inbound_plan_id}/placement-options/{placement_option_id}/transportation-options?shipment_id=shipmentId_example&status=status_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2InboundPlanApi;

import java.io.File;
import java.util.*;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearer_auth
        HttpBearerAuth bearer_auth = (HttpBearerAuth) defaultClient.getAuthentication("bearer_auth");
        bearer_auth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String placementOptionId = placementOptionId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        String status = status_example; // String | 

        try {
            selectTransportationOptions_200_response result = apiInstance.selectTransportationOptions(inboundPlanId, placementOptionId, shipmentId, status);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#selectTransportationOptions");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String placementOptionId = new String(); // String | 
final String shipmentId = new String(); // String | 
final String status = new String(); // String | 

try {
    final result = await api_instance.selectTransportationOptions(inboundPlanId, placementOptionId, shipmentId, status);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->selectTransportationOptions: $e\n');
}

import org.openapitools.client.api.V2InboundPlanApi;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String placementOptionId = placementOptionId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        String status = status_example; // String | 

        try {
            selectTransportationOptions_200_response result = apiInstance.selectTransportationOptions(inboundPlanId, placementOptionId, shipmentId, status);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#selectTransportationOptions");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearer_auth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
V2InboundPlanApi *apiInstance = [[V2InboundPlanApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *placementOptionId = placementOptionId_example; //  (default to null)
String *shipmentId = shipmentId_example; //  (optional) (default to null)
String *status = status_example; //  (optional) (default to null)

[apiInstance selectTransportationOptionsWith:inboundPlanId
    placementOptionId:placementOptionId
    shipmentId:shipmentId
    status:status
              completionHandler: ^(selectTransportationOptions_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearer_auth
var bearer_auth = defaultClient.authentications['bearer_auth'];
bearer_auth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ScanPowerApi.V2InboundPlanApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var placementOptionId = placementOptionId_example; // {String} 
var opts = {
  'shipmentId': shipmentId_example, // {String} 
  'status': status_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.selectTransportationOptions(inboundPlanId, placementOptionId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class selectTransportationOptionsExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearer_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new V2InboundPlanApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var placementOptionId = placementOptionId_example;  // String |  (default to null)
            var shipmentId = shipmentId_example;  // String |  (optional)  (default to null)
            var status = status_example;  // String |  (optional)  (default to null)

            try {
                selectTransportationOptions_200_response result = apiInstance.selectTransportationOptions(inboundPlanId, placementOptionId, shipmentId, status);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2InboundPlanApi.selectTransportationOptions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer (JWT) access token for authorization: bearer_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2InboundPlanApi();
$inboundPlanId = inboundPlanId_example; // String | 
$placementOptionId = placementOptionId_example; // String | 
$shipmentId = shipmentId_example; // String | 
$status = status_example; // String | 

try {
    $result = $api_instance->selectTransportationOptions($inboundPlanId, $placementOptionId, $shipmentId, $status);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2InboundPlanApi->selectTransportationOptions: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2InboundPlanApi;

# Configure Bearer (JWT) access token for authorization: bearer_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2InboundPlanApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $placementOptionId = placementOptionId_example; # String | 
my $shipmentId = shipmentId_example; # String | 
my $status = status_example; # String | 

eval {
    my $result = $api_instance->selectTransportationOptions(inboundPlanId => $inboundPlanId, placementOptionId => $placementOptionId, shipmentId => $shipmentId, status => $status);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2InboundPlanApi->selectTransportationOptions: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: bearer_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.V2InboundPlanApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
placementOptionId = placementOptionId_example # String |  (default to null)
shipmentId = shipmentId_example # String |  (optional) (default to null)
status = status_example # String |  (optional) (default to null)

try:
    api_response = api_instance.select_transportation_options(inboundPlanId, placementOptionId, shipmentId=shipmentId, status=status)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2InboundPlanApi->selectTransportationOptions: %s\n" % e)
extern crate V2InboundPlanApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let placementOptionId = placementOptionId_example; // String
    let shipmentId = shipmentId_example; // String
    let status = status_example; // String

    let mut context = V2InboundPlanApi::Context::default();
    let result = client.selectTransportationOptions(inboundPlanId, placementOptionId, shipmentId, status, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
inbound_plan_id*
String
Required
placement_option_id*
String
Required
Query parameters
Name Description
shipment_id
String
status
String

Responses


updateDeliveryWindowOption

Update a delivery window option in our database


/api/v2/inbound-plan/{inbound_plan_id}/shipments/{shipment_id}/delivery-window-options/{delivery_window_option_id}

Usage and SDK Samples

curl -X PATCH \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/v2/inbound-plan/{inbound_plan_id}/shipments/{shipment_id}/delivery-window-options/{delivery_window_option_id}" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2InboundPlanApi;

import java.io.File;
import java.util.*;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearer_auth
        HttpBearerAuth bearer_auth = (HttpBearerAuth) defaultClient.getAuthentication("bearer_auth");
        bearer_auth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        String deliveryWindowOptionId = deliveryWindowOptionId_example; // String | 
        V2DeliveryWindowOptionInput v2DeliveryWindowOptionInput = ; // V2DeliveryWindowOptionInput | 

        try {
            selectDeliveryWindowOption_200_response result = apiInstance.updateDeliveryWindowOption(inboundPlanId, shipmentId, deliveryWindowOptionId, v2DeliveryWindowOptionInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#updateDeliveryWindowOption");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String shipmentId = new String(); // String | 
final String deliveryWindowOptionId = new String(); // String | 
final V2DeliveryWindowOptionInput v2DeliveryWindowOptionInput = new V2DeliveryWindowOptionInput(); // V2DeliveryWindowOptionInput | 

try {
    final result = await api_instance.updateDeliveryWindowOption(inboundPlanId, shipmentId, deliveryWindowOptionId, v2DeliveryWindowOptionInput);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateDeliveryWindowOption: $e\n');
}

import org.openapitools.client.api.V2InboundPlanApi;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        String deliveryWindowOptionId = deliveryWindowOptionId_example; // String | 
        V2DeliveryWindowOptionInput v2DeliveryWindowOptionInput = ; // V2DeliveryWindowOptionInput | 

        try {
            selectDeliveryWindowOption_200_response result = apiInstance.updateDeliveryWindowOption(inboundPlanId, shipmentId, deliveryWindowOptionId, v2DeliveryWindowOptionInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#updateDeliveryWindowOption");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearer_auth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
V2InboundPlanApi *apiInstance = [[V2InboundPlanApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *shipmentId = shipmentId_example; //  (default to null)
String *deliveryWindowOptionId = deliveryWindowOptionId_example; //  (default to null)
V2DeliveryWindowOptionInput *v2DeliveryWindowOptionInput = ; //  (optional)

[apiInstance updateDeliveryWindowOptionWith:inboundPlanId
    shipmentId:shipmentId
    deliveryWindowOptionId:deliveryWindowOptionId
    v2DeliveryWindowOptionInput:v2DeliveryWindowOptionInput
              completionHandler: ^(selectDeliveryWindowOption_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearer_auth
var bearer_auth = defaultClient.authentications['bearer_auth'];
bearer_auth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ScanPowerApi.V2InboundPlanApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var shipmentId = shipmentId_example; // {String} 
var deliveryWindowOptionId = deliveryWindowOptionId_example; // {String} 
var opts = {
  'v2DeliveryWindowOptionInput':  // {V2DeliveryWindowOptionInput} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateDeliveryWindowOption(inboundPlanId, shipmentId, deliveryWindowOptionId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class updateDeliveryWindowOptionExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearer_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new V2InboundPlanApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var shipmentId = shipmentId_example;  // String |  (default to null)
            var deliveryWindowOptionId = deliveryWindowOptionId_example;  // String |  (default to null)
            var v2DeliveryWindowOptionInput = new V2DeliveryWindowOptionInput(); // V2DeliveryWindowOptionInput |  (optional) 

            try {
                selectDeliveryWindowOption_200_response result = apiInstance.updateDeliveryWindowOption(inboundPlanId, shipmentId, deliveryWindowOptionId, v2DeliveryWindowOptionInput);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2InboundPlanApi.updateDeliveryWindowOption: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer (JWT) access token for authorization: bearer_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2InboundPlanApi();
$inboundPlanId = inboundPlanId_example; // String | 
$shipmentId = shipmentId_example; // String | 
$deliveryWindowOptionId = deliveryWindowOptionId_example; // String | 
$v2DeliveryWindowOptionInput = ; // V2DeliveryWindowOptionInput | 

try {
    $result = $api_instance->updateDeliveryWindowOption($inboundPlanId, $shipmentId, $deliveryWindowOptionId, $v2DeliveryWindowOptionInput);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2InboundPlanApi->updateDeliveryWindowOption: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2InboundPlanApi;

# Configure Bearer (JWT) access token for authorization: bearer_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2InboundPlanApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $shipmentId = shipmentId_example; # String | 
my $deliveryWindowOptionId = deliveryWindowOptionId_example; # String | 
my $v2DeliveryWindowOptionInput = WWW::OPenAPIClient::Object::V2DeliveryWindowOptionInput->new(); # V2DeliveryWindowOptionInput | 

eval {
    my $result = $api_instance->updateDeliveryWindowOption(inboundPlanId => $inboundPlanId, shipmentId => $shipmentId, deliveryWindowOptionId => $deliveryWindowOptionId, v2DeliveryWindowOptionInput => $v2DeliveryWindowOptionInput);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2InboundPlanApi->updateDeliveryWindowOption: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: bearer_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.V2InboundPlanApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
shipmentId = shipmentId_example # String |  (default to null)
deliveryWindowOptionId = deliveryWindowOptionId_example # String |  (default to null)
v2DeliveryWindowOptionInput =  # V2DeliveryWindowOptionInput |  (optional)

try:
    api_response = api_instance.update_delivery_window_option(inboundPlanId, shipmentId, deliveryWindowOptionId, v2DeliveryWindowOptionInput=v2DeliveryWindowOptionInput)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2InboundPlanApi->updateDeliveryWindowOption: %s\n" % e)
extern crate V2InboundPlanApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let shipmentId = shipmentId_example; // String
    let deliveryWindowOptionId = deliveryWindowOptionId_example; // String
    let v2DeliveryWindowOptionInput = ; // V2DeliveryWindowOptionInput

    let mut context = V2InboundPlanApi::Context::default();
    let result = client.updateDeliveryWindowOption(inboundPlanId, shipmentId, deliveryWindowOptionId, v2DeliveryWindowOptionInput, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
inbound_plan_id*
String
Required
shipment_id*
String
Required
delivery_window_option_id*
String
Required
Body parameters
Name Description
v2DeliveryWindowOptionInput

Responses


updateInboundPlan

Udpate an inbound plan


/api/v2/inbound-plan/{inbound_plan_id}

Usage and SDK Samples

curl -X PATCH \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/v2/inbound-plan/{inbound_plan_id}" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2InboundPlanApi;

import java.io.File;
import java.util.*;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearer_auth
        HttpBearerAuth bearer_auth = (HttpBearerAuth) defaultClient.getAuthentication("bearer_auth");
        bearer_auth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        V2InboundPlanInput v2InboundPlanInput = ; // V2InboundPlanInput | 

        try {
            selectInboundPlan_200_response result = apiInstance.updateInboundPlan(inboundPlanId, v2InboundPlanInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#updateInboundPlan");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final V2InboundPlanInput v2InboundPlanInput = new V2InboundPlanInput(); // V2InboundPlanInput | 

try {
    final result = await api_instance.updateInboundPlan(inboundPlanId, v2InboundPlanInput);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateInboundPlan: $e\n');
}

import org.openapitools.client.api.V2InboundPlanApi;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        V2InboundPlanInput v2InboundPlanInput = ; // V2InboundPlanInput | 

        try {
            selectInboundPlan_200_response result = apiInstance.updateInboundPlan(inboundPlanId, v2InboundPlanInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#updateInboundPlan");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearer_auth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
V2InboundPlanApi *apiInstance = [[V2InboundPlanApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
V2InboundPlanInput *v2InboundPlanInput = ; //  (optional)

[apiInstance updateInboundPlanWith:inboundPlanId
    v2InboundPlanInput:v2InboundPlanInput
              completionHandler: ^(selectInboundPlan_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearer_auth
var bearer_auth = defaultClient.authentications['bearer_auth'];
bearer_auth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ScanPowerApi.V2InboundPlanApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var opts = {
  'v2InboundPlanInput':  // {V2InboundPlanInput} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateInboundPlan(inboundPlanId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class updateInboundPlanExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearer_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new V2InboundPlanApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var v2InboundPlanInput = new V2InboundPlanInput(); // V2InboundPlanInput |  (optional) 

            try {
                selectInboundPlan_200_response result = apiInstance.updateInboundPlan(inboundPlanId, v2InboundPlanInput);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2InboundPlanApi.updateInboundPlan: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer (JWT) access token for authorization: bearer_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2InboundPlanApi();
$inboundPlanId = inboundPlanId_example; // String | 
$v2InboundPlanInput = ; // V2InboundPlanInput | 

try {
    $result = $api_instance->updateInboundPlan($inboundPlanId, $v2InboundPlanInput);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2InboundPlanApi->updateInboundPlan: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2InboundPlanApi;

# Configure Bearer (JWT) access token for authorization: bearer_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2InboundPlanApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $v2InboundPlanInput = WWW::OPenAPIClient::Object::V2InboundPlanInput->new(); # V2InboundPlanInput | 

eval {
    my $result = $api_instance->updateInboundPlan(inboundPlanId => $inboundPlanId, v2InboundPlanInput => $v2InboundPlanInput);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2InboundPlanApi->updateInboundPlan: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: bearer_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.V2InboundPlanApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
v2InboundPlanInput =  # V2InboundPlanInput |  (optional)

try:
    api_response = api_instance.update_inbound_plan(inboundPlanId, v2InboundPlanInput=v2InboundPlanInput)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2InboundPlanApi->updateInboundPlan: %s\n" % e)
extern crate V2InboundPlanApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let v2InboundPlanInput = ; // V2InboundPlanInput

    let mut context = V2InboundPlanApi::Context::default();
    let result = client.updateInboundPlan(inboundPlanId, v2InboundPlanInput, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
inbound_plan_id*
String
Required
Body parameters
Name Description
v2InboundPlanInput

Responses


updatePlacementOption

Update a placement option


/api/v2/inbound-plan/{inbound_plan_id}/placement-options/{placement_option_id}

Usage and SDK Samples

curl -X PATCH \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/v2/inbound-plan/{inbound_plan_id}/placement-options/{placement_option_id}" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2InboundPlanApi;

import java.io.File;
import java.util.*;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearer_auth
        HttpBearerAuth bearer_auth = (HttpBearerAuth) defaultClient.getAuthentication("bearer_auth");
        bearer_auth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String placementOptionId = placementOptionId_example; // String | 
        SpapiPlacementOption spapiPlacementOption = ; // SpapiPlacementOption | 

        try {
            insertPlacementOption_200_response result = apiInstance.updatePlacementOption(inboundPlanId, placementOptionId, spapiPlacementOption);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#updatePlacementOption");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String placementOptionId = new String(); // String | 
final SpapiPlacementOption spapiPlacementOption = new SpapiPlacementOption(); // SpapiPlacementOption | 

try {
    final result = await api_instance.updatePlacementOption(inboundPlanId, placementOptionId, spapiPlacementOption);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updatePlacementOption: $e\n');
}

import org.openapitools.client.api.V2InboundPlanApi;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String placementOptionId = placementOptionId_example; // String | 
        SpapiPlacementOption spapiPlacementOption = ; // SpapiPlacementOption | 

        try {
            insertPlacementOption_200_response result = apiInstance.updatePlacementOption(inboundPlanId, placementOptionId, spapiPlacementOption);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#updatePlacementOption");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearer_auth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
V2InboundPlanApi *apiInstance = [[V2InboundPlanApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *placementOptionId = placementOptionId_example; //  (default to null)
SpapiPlacementOption *spapiPlacementOption = ; //  (optional)

[apiInstance updatePlacementOptionWith:inboundPlanId
    placementOptionId:placementOptionId
    spapiPlacementOption:spapiPlacementOption
              completionHandler: ^(insertPlacementOption_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearer_auth
var bearer_auth = defaultClient.authentications['bearer_auth'];
bearer_auth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ScanPowerApi.V2InboundPlanApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var placementOptionId = placementOptionId_example; // {String} 
var opts = {
  'spapiPlacementOption':  // {SpapiPlacementOption} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updatePlacementOption(inboundPlanId, placementOptionId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class updatePlacementOptionExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearer_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new V2InboundPlanApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var placementOptionId = placementOptionId_example;  // String |  (default to null)
            var spapiPlacementOption = new SpapiPlacementOption(); // SpapiPlacementOption |  (optional) 

            try {
                insertPlacementOption_200_response result = apiInstance.updatePlacementOption(inboundPlanId, placementOptionId, spapiPlacementOption);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2InboundPlanApi.updatePlacementOption: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer (JWT) access token for authorization: bearer_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2InboundPlanApi();
$inboundPlanId = inboundPlanId_example; // String | 
$placementOptionId = placementOptionId_example; // String | 
$spapiPlacementOption = ; // SpapiPlacementOption | 

try {
    $result = $api_instance->updatePlacementOption($inboundPlanId, $placementOptionId, $spapiPlacementOption);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2InboundPlanApi->updatePlacementOption: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2InboundPlanApi;

# Configure Bearer (JWT) access token for authorization: bearer_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2InboundPlanApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $placementOptionId = placementOptionId_example; # String | 
my $spapiPlacementOption = WWW::OPenAPIClient::Object::SpapiPlacementOption->new(); # SpapiPlacementOption | 

eval {
    my $result = $api_instance->updatePlacementOption(inboundPlanId => $inboundPlanId, placementOptionId => $placementOptionId, spapiPlacementOption => $spapiPlacementOption);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2InboundPlanApi->updatePlacementOption: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: bearer_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.V2InboundPlanApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
placementOptionId = placementOptionId_example # String |  (default to null)
spapiPlacementOption =  # SpapiPlacementOption |  (optional)

try:
    api_response = api_instance.update_placement_option(inboundPlanId, placementOptionId, spapiPlacementOption=spapiPlacementOption)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2InboundPlanApi->updatePlacementOption: %s\n" % e)
extern crate V2InboundPlanApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let placementOptionId = placementOptionId_example; // String
    let spapiPlacementOption = ; // SpapiPlacementOption

    let mut context = V2InboundPlanApi::Context::default();
    let result = client.updatePlacementOption(inboundPlanId, placementOptionId, spapiPlacementOption, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
inbound_plan_id*
String
Required
placement_option_id*
String
Required
Body parameters
Name Description
spapiPlacementOption

Responses


updateShipment

Update an AZ shipment in our database


/api/v2/inbound-plan/{inbound_plan_id}/shipments/{shipment_id}

Usage and SDK Samples

curl -X PATCH \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/v2/inbound-plan/{inbound_plan_id}/shipments/{shipment_id}" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2InboundPlanApi;

import java.io.File;
import java.util.*;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearer_auth
        HttpBearerAuth bearer_auth = (HttpBearerAuth) defaultClient.getAuthentication("bearer_auth");
        bearer_auth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        V2ShipmentInput v2ShipmentInput = ; // V2ShipmentInput | 

        try {
            insertShipment_200_response result = apiInstance.updateShipment(inboundPlanId, shipmentId, v2ShipmentInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#updateShipment");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String shipmentId = new String(); // String | 
final V2ShipmentInput v2ShipmentInput = new V2ShipmentInput(); // V2ShipmentInput | 

try {
    final result = await api_instance.updateShipment(inboundPlanId, shipmentId, v2ShipmentInput);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateShipment: $e\n');
}

import org.openapitools.client.api.V2InboundPlanApi;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String shipmentId = shipmentId_example; // String | 
        V2ShipmentInput v2ShipmentInput = ; // V2ShipmentInput | 

        try {
            insertShipment_200_response result = apiInstance.updateShipment(inboundPlanId, shipmentId, v2ShipmentInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#updateShipment");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearer_auth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
V2InboundPlanApi *apiInstance = [[V2InboundPlanApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *shipmentId = shipmentId_example; //  (default to null)
V2ShipmentInput *v2ShipmentInput = ; //  (optional)

[apiInstance updateShipmentWith:inboundPlanId
    shipmentId:shipmentId
    v2ShipmentInput:v2ShipmentInput
              completionHandler: ^(insertShipment_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearer_auth
var bearer_auth = defaultClient.authentications['bearer_auth'];
bearer_auth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ScanPowerApi.V2InboundPlanApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var shipmentId = shipmentId_example; // {String} 
var opts = {
  'v2ShipmentInput':  // {V2ShipmentInput} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateShipment(inboundPlanId, shipmentId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class updateShipmentExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearer_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new V2InboundPlanApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var shipmentId = shipmentId_example;  // String |  (default to null)
            var v2ShipmentInput = new V2ShipmentInput(); // V2ShipmentInput |  (optional) 

            try {
                insertShipment_200_response result = apiInstance.updateShipment(inboundPlanId, shipmentId, v2ShipmentInput);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2InboundPlanApi.updateShipment: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer (JWT) access token for authorization: bearer_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2InboundPlanApi();
$inboundPlanId = inboundPlanId_example; // String | 
$shipmentId = shipmentId_example; // String | 
$v2ShipmentInput = ; // V2ShipmentInput | 

try {
    $result = $api_instance->updateShipment($inboundPlanId, $shipmentId, $v2ShipmentInput);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2InboundPlanApi->updateShipment: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2InboundPlanApi;

# Configure Bearer (JWT) access token for authorization: bearer_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2InboundPlanApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $shipmentId = shipmentId_example; # String | 
my $v2ShipmentInput = WWW::OPenAPIClient::Object::V2ShipmentInput->new(); # V2ShipmentInput | 

eval {
    my $result = $api_instance->updateShipment(inboundPlanId => $inboundPlanId, shipmentId => $shipmentId, v2ShipmentInput => $v2ShipmentInput);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2InboundPlanApi->updateShipment: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: bearer_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.V2InboundPlanApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
shipmentId = shipmentId_example # String |  (default to null)
v2ShipmentInput =  # V2ShipmentInput |  (optional)

try:
    api_response = api_instance.update_shipment(inboundPlanId, shipmentId, v2ShipmentInput=v2ShipmentInput)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2InboundPlanApi->updateShipment: %s\n" % e)
extern crate V2InboundPlanApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let shipmentId = shipmentId_example; // String
    let v2ShipmentInput = ; // V2ShipmentInput

    let mut context = V2InboundPlanApi::Context::default();
    let result = client.updateShipment(inboundPlanId, shipmentId, v2ShipmentInput, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
inbound_plan_id*
String
Required
shipment_id*
String
Required
Body parameters
Name Description
v2ShipmentInput

Responses


updateTransportationOption

Load the given transportation option by id


/api/v2/inbound-plan/{inbound_plan_id}/placement-options/{placement_option_id}/transportation-options/{transportation_option_id}

Usage and SDK Samples

curl -X PATCH \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/v2/inbound-plan/{inbound_plan_id}/placement-options/{placement_option_id}/transportation-options/{transportation_option_id}" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2InboundPlanApi;

import java.io.File;
import java.util.*;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearer_auth
        HttpBearerAuth bearer_auth = (HttpBearerAuth) defaultClient.getAuthentication("bearer_auth");
        bearer_auth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String placementOptionId = placementOptionId_example; // String | 
        String transportationOptionId = transportationOptionId_example; // String | 
        V2TransportationOptionInput v2TransportationOptionInput = ; // V2TransportationOptionInput | 

        try {
            selectTransportationOption_200_response result = apiInstance.updateTransportationOption(inboundPlanId, placementOptionId, transportationOptionId, v2TransportationOptionInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#updateTransportationOption");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inboundPlanId = new String(); // String | 
final String placementOptionId = new String(); // String | 
final String transportationOptionId = new String(); // String | 
final V2TransportationOptionInput v2TransportationOptionInput = new V2TransportationOptionInput(); // V2TransportationOptionInput | 

try {
    final result = await api_instance.updateTransportationOption(inboundPlanId, placementOptionId, transportationOptionId, v2TransportationOptionInput);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateTransportationOption: $e\n');
}

import org.openapitools.client.api.V2InboundPlanApi;

public class V2InboundPlanApiExample {
    public static void main(String[] args) {
        V2InboundPlanApi apiInstance = new V2InboundPlanApi();
        String inboundPlanId = inboundPlanId_example; // String | 
        String placementOptionId = placementOptionId_example; // String | 
        String transportationOptionId = transportationOptionId_example; // String | 
        V2TransportationOptionInput v2TransportationOptionInput = ; // V2TransportationOptionInput | 

        try {
            selectTransportationOption_200_response result = apiInstance.updateTransportationOption(inboundPlanId, placementOptionId, transportationOptionId, v2TransportationOptionInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InboundPlanApi#updateTransportationOption");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearer_auth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
V2InboundPlanApi *apiInstance = [[V2InboundPlanApi alloc] init];
String *inboundPlanId = inboundPlanId_example; //  (default to null)
String *placementOptionId = placementOptionId_example; //  (default to null)
String *transportationOptionId = transportationOptionId_example; //  (default to null)
V2TransportationOptionInput *v2TransportationOptionInput = ; //  (optional)

[apiInstance updateTransportationOptionWith:inboundPlanId
    placementOptionId:placementOptionId
    transportationOptionId:transportationOptionId
    v2TransportationOptionInput:v2TransportationOptionInput
              completionHandler: ^(selectTransportationOption_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearer_auth
var bearer_auth = defaultClient.authentications['bearer_auth'];
bearer_auth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ScanPowerApi.V2InboundPlanApi()
var inboundPlanId = inboundPlanId_example; // {String} 
var placementOptionId = placementOptionId_example; // {String} 
var transportationOptionId = transportationOptionId_example; // {String} 
var opts = {
  'v2TransportationOptionInput':  // {V2TransportationOptionInput} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateTransportationOption(inboundPlanId, placementOptionId, transportationOptionId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class updateTransportationOptionExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearer_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new V2InboundPlanApi();
            var inboundPlanId = inboundPlanId_example;  // String |  (default to null)
            var placementOptionId = placementOptionId_example;  // String |  (default to null)
            var transportationOptionId = transportationOptionId_example;  // String |  (default to null)
            var v2TransportationOptionInput = new V2TransportationOptionInput(); // V2TransportationOptionInput |  (optional) 

            try {
                selectTransportationOption_200_response result = apiInstance.updateTransportationOption(inboundPlanId, placementOptionId, transportationOptionId, v2TransportationOptionInput);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2InboundPlanApi.updateTransportationOption: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer (JWT) access token for authorization: bearer_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2InboundPlanApi();
$inboundPlanId = inboundPlanId_example; // String | 
$placementOptionId = placementOptionId_example; // String | 
$transportationOptionId = transportationOptionId_example; // String | 
$v2TransportationOptionInput = ; // V2TransportationOptionInput | 

try {
    $result = $api_instance->updateTransportationOption($inboundPlanId, $placementOptionId, $transportationOptionId, $v2TransportationOptionInput);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2InboundPlanApi->updateTransportationOption: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2InboundPlanApi;

# Configure Bearer (JWT) access token for authorization: bearer_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2InboundPlanApi->new();
my $inboundPlanId = inboundPlanId_example; # String | 
my $placementOptionId = placementOptionId_example; # String | 
my $transportationOptionId = transportationOptionId_example; # String | 
my $v2TransportationOptionInput = WWW::OPenAPIClient::Object::V2TransportationOptionInput->new(); # V2TransportationOptionInput | 

eval {
    my $result = $api_instance->updateTransportationOption(inboundPlanId => $inboundPlanId, placementOptionId => $placementOptionId, transportationOptionId => $transportationOptionId, v2TransportationOptionInput => $v2TransportationOptionInput);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2InboundPlanApi->updateTransportationOption: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: bearer_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.V2InboundPlanApi()
inboundPlanId = inboundPlanId_example # String |  (default to null)
placementOptionId = placementOptionId_example # String |  (default to null)
transportationOptionId = transportationOptionId_example # String |  (default to null)
v2TransportationOptionInput =  # V2TransportationOptionInput |  (optional)

try:
    api_response = api_instance.update_transportation_option(inboundPlanId, placementOptionId, transportationOptionId, v2TransportationOptionInput=v2TransportationOptionInput)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2InboundPlanApi->updateTransportationOption: %s\n" % e)
extern crate V2InboundPlanApi;

pub fn main() {
    let inboundPlanId = inboundPlanId_example; // String
    let placementOptionId = placementOptionId_example; // String
    let transportationOptionId = transportationOptionId_example; // String
    let v2TransportationOptionInput = ; // V2TransportationOptionInput

    let mut context = V2InboundPlanApi::Context::default();
    let result = client.updateTransportationOption(inboundPlanId, placementOptionId, transportationOptionId, v2TransportationOptionInput, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
inbound_plan_id*
String
Required
placement_option_id*
String
Required
transportation_option_id*
String
Required
Body parameters
Name Description
v2TransportationOptionInput

Responses


V2Inventory

selectInventory

Get your inventory

All currency amounts are in the smallest currency unit (ie. cents) and are assumed to be in the currency that matches the marketplace (eg. USD for US, CAD for CA, etc.)


/api/v2/inventory

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/v2/inventory?offset=56&limit=56" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2InventoryApi;

import java.io.File;
import java.util.*;

public class V2InventoryApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearer_auth
        HttpBearerAuth bearer_auth = (HttpBearerAuth) defaultClient.getAuthentication("bearer_auth");
        bearer_auth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        V2InventoryApi apiInstance = new V2InventoryApi();
        Integer offset = 56; // Integer | An integer offset used for paging
        Integer limit = 56; // Integer | The number of rows to fetch. Defaults to 100
        SelectInventoryRequest selectInventoryRequest = {"filters":{}}; // SelectInventoryRequest | 

        try {
            selectInventory_200_response result = apiInstance.selectInventory(offset, limit, selectInventoryRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InventoryApi#selectInventory");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer offset = new Integer(); // Integer | An integer offset used for paging
final Integer limit = new Integer(); // Integer | The number of rows to fetch. Defaults to 100
final SelectInventoryRequest selectInventoryRequest = new SelectInventoryRequest(); // SelectInventoryRequest | 

try {
    final result = await api_instance.selectInventory(offset, limit, selectInventoryRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->selectInventory: $e\n');
}

import org.openapitools.client.api.V2InventoryApi;

public class V2InventoryApiExample {
    public static void main(String[] args) {
        V2InventoryApi apiInstance = new V2InventoryApi();
        Integer offset = 56; // Integer | An integer offset used for paging
        Integer limit = 56; // Integer | The number of rows to fetch. Defaults to 100
        SelectInventoryRequest selectInventoryRequest = {"filters":{}}; // SelectInventoryRequest | 

        try {
            selectInventory_200_response result = apiInstance.selectInventory(offset, limit, selectInventoryRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2InventoryApi#selectInventory");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearer_auth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
V2InventoryApi *apiInstance = [[V2InventoryApi alloc] init];
Integer *offset = 56; // An integer offset used for paging (optional) (default to null)
Integer *limit = 56; // The number of rows to fetch. Defaults to 100 (optional) (default to null)
SelectInventoryRequest *selectInventoryRequest = {"filters":{}}; //  (optional)

// Get your inventory
[apiInstance selectInventoryWith:offset
    limit:limit
    selectInventoryRequest:selectInventoryRequest
              completionHandler: ^(selectInventory_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearer_auth
var bearer_auth = defaultClient.authentications['bearer_auth'];
bearer_auth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ScanPowerApi.V2InventoryApi()
var opts = {
  'offset': 56, // {Integer} An integer offset used for paging
  'limit': 56, // {Integer} The number of rows to fetch. Defaults to 100
  'selectInventoryRequest': {"filters":{}} // {SelectInventoryRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.selectInventory(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class selectInventoryExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearer_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new V2InventoryApi();
            var offset = 56;  // Integer | An integer offset used for paging (optional)  (default to null)
            var limit = 56;  // Integer | The number of rows to fetch. Defaults to 100 (optional)  (default to null)
            var selectInventoryRequest = new SelectInventoryRequest(); // SelectInventoryRequest |  (optional) 

            try {
                // Get your inventory
                selectInventory_200_response result = apiInstance.selectInventory(offset, limit, selectInventoryRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2InventoryApi.selectInventory: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer (JWT) access token for authorization: bearer_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2InventoryApi();
$offset = 56; // Integer | An integer offset used for paging
$limit = 56; // Integer | The number of rows to fetch. Defaults to 100
$selectInventoryRequest = {"filters":{}}; // SelectInventoryRequest | 

try {
    $result = $api_instance->selectInventory($offset, $limit, $selectInventoryRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2InventoryApi->selectInventory: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2InventoryApi;

# Configure Bearer (JWT) access token for authorization: bearer_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2InventoryApi->new();
my $offset = 56; # Integer | An integer offset used for paging
my $limit = 56; # Integer | The number of rows to fetch. Defaults to 100
my $selectInventoryRequest = WWW::OPenAPIClient::Object::SelectInventoryRequest->new(); # SelectInventoryRequest | 

eval {
    my $result = $api_instance->selectInventory(offset => $offset, limit => $limit, selectInventoryRequest => $selectInventoryRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2InventoryApi->selectInventory: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: bearer_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.V2InventoryApi()
offset = 56 # Integer | An integer offset used for paging (optional) (default to null)
limit = 56 # Integer | The number of rows to fetch. Defaults to 100 (optional) (default to null)
selectInventoryRequest = {"filters":{}} # SelectInventoryRequest |  (optional)

try:
    # Get your inventory
    api_response = api_instance.select_inventory(offset=offset, limit=limit, selectInventoryRequest=selectInventoryRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2InventoryApi->selectInventory: %s\n" % e)
extern crate V2InventoryApi;

pub fn main() {
    let offset = 56; // Integer
    let limit = 56; // Integer
    let selectInventoryRequest = {"filters":{}}; // SelectInventoryRequest

    let mut context = V2InventoryApi::Context::default();
    let result = client.selectInventory(offset, limit, selectInventoryRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
selectInventoryRequest

Optional filters to apply to the inventory records

Query parameters
Name Description
offset
Integer
An integer offset used for paging
limit
Integer
The number of rows to fetch. Defaults to 100

Responses


V2Pallets

deletePallet


/api/v2/pallet/{pallet_id}

Usage and SDK Samples

curl -X DELETE \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/v2/pallet/{pallet_id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2PalletsApi;

import java.io.File;
import java.util.*;

public class V2PalletsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearer_auth
        HttpBearerAuth bearer_auth = (HttpBearerAuth) defaultClient.getAuthentication("bearer_auth");
        bearer_auth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        V2PalletsApi apiInstance = new V2PalletsApi();
        String palletId = palletId_example; // String | The id of the pallet to delete

        try {
            insertPallet_200_response result = apiInstance.deletePallet(palletId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2PalletsApi#deletePallet");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String palletId = new String(); // String | The id of the pallet to delete

try {
    final result = await api_instance.deletePallet(palletId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deletePallet: $e\n');
}

import org.openapitools.client.api.V2PalletsApi;

public class V2PalletsApiExample {
    public static void main(String[] args) {
        V2PalletsApi apiInstance = new V2PalletsApi();
        String palletId = palletId_example; // String | The id of the pallet to delete

        try {
            insertPallet_200_response result = apiInstance.deletePallet(palletId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2PalletsApi#deletePallet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearer_auth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
V2PalletsApi *apiInstance = [[V2PalletsApi alloc] init];
String *palletId = palletId_example; // The id of the pallet to delete (default to null)

[apiInstance deletePalletWith:palletId
              completionHandler: ^(insertPallet_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearer_auth
var bearer_auth = defaultClient.authentications['bearer_auth'];
bearer_auth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ScanPowerApi.V2PalletsApi()
var palletId = palletId_example; // {String} The id of the pallet to delete

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deletePallet(palletId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class deletePalletExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearer_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new V2PalletsApi();
            var palletId = palletId_example;  // String | The id of the pallet to delete (default to null)

            try {
                insertPallet_200_response result = apiInstance.deletePallet(palletId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2PalletsApi.deletePallet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer (JWT) access token for authorization: bearer_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2PalletsApi();
$palletId = palletId_example; // String | The id of the pallet to delete

try {
    $result = $api_instance->deletePallet($palletId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2PalletsApi->deletePallet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2PalletsApi;

# Configure Bearer (JWT) access token for authorization: bearer_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2PalletsApi->new();
my $palletId = palletId_example; # String | The id of the pallet to delete

eval {
    my $result = $api_instance->deletePallet(palletId => $palletId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2PalletsApi->deletePallet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: bearer_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.V2PalletsApi()
palletId = palletId_example # String | The id of the pallet to delete (default to null)

try:
    api_response = api_instance.delete_pallet(palletId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2PalletsApi->deletePallet: %s\n" % e)
extern crate V2PalletsApi;

pub fn main() {
    let palletId = palletId_example; // String

    let mut context = V2PalletsApi::Context::default();
    let result = client.deletePallet(palletId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
pallet_id*
String
The id of the pallet to delete
Required

Responses


insertPallet


/api/v2/pallet

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/v2/pallet" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2PalletsApi;

import java.io.File;
import java.util.*;

public class V2PalletsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearer_auth
        HttpBearerAuth bearer_auth = (HttpBearerAuth) defaultClient.getAuthentication("bearer_auth");
        bearer_auth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        V2PalletsApi apiInstance = new V2PalletsApi();
        InsertPalletRequest insertPalletRequest = ; // InsertPalletRequest | 

        try {
            insertPallet_200_response result = apiInstance.insertPallet(insertPalletRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2PalletsApi#insertPallet");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final InsertPalletRequest insertPalletRequest = new InsertPalletRequest(); // InsertPalletRequest | 

try {
    final result = await api_instance.insertPallet(insertPalletRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->insertPallet: $e\n');
}

import org.openapitools.client.api.V2PalletsApi;

public class V2PalletsApiExample {
    public static void main(String[] args) {
        V2PalletsApi apiInstance = new V2PalletsApi();
        InsertPalletRequest insertPalletRequest = ; // InsertPalletRequest | 

        try {
            insertPallet_200_response result = apiInstance.insertPallet(insertPalletRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2PalletsApi#insertPallet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearer_auth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
V2PalletsApi *apiInstance = [[V2PalletsApi alloc] init];
InsertPalletRequest *insertPalletRequest = ; //  (optional)

[apiInstance insertPalletWith:insertPalletRequest
              completionHandler: ^(insertPallet_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearer_auth
var bearer_auth = defaultClient.authentications['bearer_auth'];
bearer_auth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ScanPowerApi.V2PalletsApi()
var opts = {
  'insertPalletRequest':  // {InsertPalletRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.insertPallet(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class insertPalletExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearer_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new V2PalletsApi();
            var insertPalletRequest = new InsertPalletRequest(); // InsertPalletRequest |  (optional) 

            try {
                insertPallet_200_response result = apiInstance.insertPallet(insertPalletRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2PalletsApi.insertPallet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer (JWT) access token for authorization: bearer_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2PalletsApi();
$insertPalletRequest = ; // InsertPalletRequest | 

try {
    $result = $api_instance->insertPallet($insertPalletRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2PalletsApi->insertPallet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2PalletsApi;

# Configure Bearer (JWT) access token for authorization: bearer_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2PalletsApi->new();
my $insertPalletRequest = WWW::OPenAPIClient::Object::InsertPalletRequest->new(); # InsertPalletRequest | 

eval {
    my $result = $api_instance->insertPallet(insertPalletRequest => $insertPalletRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2PalletsApi->insertPallet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: bearer_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.V2PalletsApi()
insertPalletRequest =  # InsertPalletRequest |  (optional)

try:
    api_response = api_instance.insert_pallet(insertPalletRequest=insertPalletRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2PalletsApi->insertPallet: %s\n" % e)
extern crate V2PalletsApi;

pub fn main() {
    let insertPalletRequest = ; // InsertPalletRequest

    let mut context = V2PalletsApi::Context::default();
    let result = client.insertPallet(insertPalletRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
insertPalletRequest

Responses


selectPallet


/api/v2/pallet/{pallet_id}

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/v2/pallet/{pallet_id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2PalletsApi;

import java.io.File;
import java.util.*;

public class V2PalletsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearer_auth
        HttpBearerAuth bearer_auth = (HttpBearerAuth) defaultClient.getAuthentication("bearer_auth");
        bearer_auth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        V2PalletsApi apiInstance = new V2PalletsApi();
        String palletId = palletId_example; // String | The id of the pallet to get

        try {
            insertPallet_200_response result = apiInstance.selectPallet(palletId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2PalletsApi#selectPallet");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String palletId = new String(); // String | The id of the pallet to get

try {
    final result = await api_instance.selectPallet(palletId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->selectPallet: $e\n');
}

import org.openapitools.client.api.V2PalletsApi;

public class V2PalletsApiExample {
    public static void main(String[] args) {
        V2PalletsApi apiInstance = new V2PalletsApi();
        String palletId = palletId_example; // String | The id of the pallet to get

        try {
            insertPallet_200_response result = apiInstance.selectPallet(palletId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2PalletsApi#selectPallet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearer_auth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
V2PalletsApi *apiInstance = [[V2PalletsApi alloc] init];
String *palletId = palletId_example; // The id of the pallet to get (default to null)

[apiInstance selectPalletWith:palletId
              completionHandler: ^(insertPallet_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearer_auth
var bearer_auth = defaultClient.authentications['bearer_auth'];
bearer_auth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ScanPowerApi.V2PalletsApi()
var palletId = palletId_example; // {String} The id of the pallet to get

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.selectPallet(palletId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class selectPalletExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearer_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new V2PalletsApi();
            var palletId = palletId_example;  // String | The id of the pallet to get (default to null)

            try {
                insertPallet_200_response result = apiInstance.selectPallet(palletId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2PalletsApi.selectPallet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer (JWT) access token for authorization: bearer_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2PalletsApi();
$palletId = palletId_example; // String | The id of the pallet to get

try {
    $result = $api_instance->selectPallet($palletId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2PalletsApi->selectPallet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2PalletsApi;

# Configure Bearer (JWT) access token for authorization: bearer_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2PalletsApi->new();
my $palletId = palletId_example; # String | The id of the pallet to get

eval {
    my $result = $api_instance->selectPallet(palletId => $palletId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2PalletsApi->selectPallet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: bearer_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.V2PalletsApi()
palletId = palletId_example # String | The id of the pallet to get (default to null)

try:
    api_response = api_instance.select_pallet(palletId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2PalletsApi->selectPallet: %s\n" % e)
extern crate V2PalletsApi;

pub fn main() {
    let palletId = palletId_example; // String

    let mut context = V2PalletsApi::Context::default();
    let result = client.selectPallet(palletId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
pallet_id*
String
The id of the pallet to get
Required

Responses


selectPallets


/api/v2/pallet

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/v2/pallet?v1_batch_id=v1BatchId_example&v2_batch_id=v2BatchId_example&shipment_id=shipmentId_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2PalletsApi;

import java.io.File;
import java.util.*;

public class V2PalletsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearer_auth
        HttpBearerAuth bearer_auth = (HttpBearerAuth) defaultClient.getAuthentication("bearer_auth");
        bearer_auth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        V2PalletsApi apiInstance = new V2PalletsApi();
        String v1BatchId = v1BatchId_example; // String | The id of the v1 batch to load pallets for
        String v2BatchId = v2BatchId_example; // String | The id of the v2 batch to load pallets for
        String shipmentId = shipmentId_example; // String | The id of the v2 shipment to load pallets for

        try {
            selectPallets_200_response result = apiInstance.selectPallets(v1BatchId, v2BatchId, shipmentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2PalletsApi#selectPallets");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String v1BatchId = new String(); // String | The id of the v1 batch to load pallets for
final String v2BatchId = new String(); // String | The id of the v2 batch to load pallets for
final String shipmentId = new String(); // String | The id of the v2 shipment to load pallets for

try {
    final result = await api_instance.selectPallets(v1BatchId, v2BatchId, shipmentId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->selectPallets: $e\n');
}

import org.openapitools.client.api.V2PalletsApi;

public class V2PalletsApiExample {
    public static void main(String[] args) {
        V2PalletsApi apiInstance = new V2PalletsApi();
        String v1BatchId = v1BatchId_example; // String | The id of the v1 batch to load pallets for
        String v2BatchId = v2BatchId_example; // String | The id of the v2 batch to load pallets for
        String shipmentId = shipmentId_example; // String | The id of the v2 shipment to load pallets for

        try {
            selectPallets_200_response result = apiInstance.selectPallets(v1BatchId, v2BatchId, shipmentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2PalletsApi#selectPallets");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearer_auth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
V2PalletsApi *apiInstance = [[V2PalletsApi alloc] init];
String *v1BatchId = v1BatchId_example; // The id of the v1 batch to load pallets for (optional) (default to null)
String *v2BatchId = v2BatchId_example; // The id of the v2 batch to load pallets for (optional) (default to null)
String *shipmentId = shipmentId_example; // The id of the v2 shipment to load pallets for (optional) (default to null)

[apiInstance selectPalletsWith:v1BatchId
    v2BatchId:v2BatchId
    shipmentId:shipmentId
              completionHandler: ^(selectPallets_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearer_auth
var bearer_auth = defaultClient.authentications['bearer_auth'];
bearer_auth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ScanPowerApi.V2PalletsApi()
var opts = {
  'v1BatchId': v1BatchId_example, // {String} The id of the v1 batch to load pallets for
  'v2BatchId': v2BatchId_example, // {String} The id of the v2 batch to load pallets for
  'shipmentId': shipmentId_example // {String} The id of the v2 shipment to load pallets for
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.selectPallets(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class selectPalletsExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearer_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new V2PalletsApi();
            var v1BatchId = v1BatchId_example;  // String | The id of the v1 batch to load pallets for (optional)  (default to null)
            var v2BatchId = v2BatchId_example;  // String | The id of the v2 batch to load pallets for (optional)  (default to null)
            var shipmentId = shipmentId_example;  // String | The id of the v2 shipment to load pallets for (optional)  (default to null)

            try {
                selectPallets_200_response result = apiInstance.selectPallets(v1BatchId, v2BatchId, shipmentId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2PalletsApi.selectPallets: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer (JWT) access token for authorization: bearer_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2PalletsApi();
$v1BatchId = v1BatchId_example; // String | The id of the v1 batch to load pallets for
$v2BatchId = v2BatchId_example; // String | The id of the v2 batch to load pallets for
$shipmentId = shipmentId_example; // String | The id of the v2 shipment to load pallets for

try {
    $result = $api_instance->selectPallets($v1BatchId, $v2BatchId, $shipmentId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2PalletsApi->selectPallets: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2PalletsApi;

# Configure Bearer (JWT) access token for authorization: bearer_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2PalletsApi->new();
my $v1BatchId = v1BatchId_example; # String | The id of the v1 batch to load pallets for
my $v2BatchId = v2BatchId_example; # String | The id of the v2 batch to load pallets for
my $shipmentId = shipmentId_example; # String | The id of the v2 shipment to load pallets for

eval {
    my $result = $api_instance->selectPallets(v1BatchId => $v1BatchId, v2BatchId => $v2BatchId, shipmentId => $shipmentId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2PalletsApi->selectPallets: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: bearer_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.V2PalletsApi()
v1BatchId = v1BatchId_example # String | The id of the v1 batch to load pallets for (optional) (default to null)
v2BatchId = v2BatchId_example # String | The id of the v2 batch to load pallets for (optional) (default to null)
shipmentId = shipmentId_example # String | The id of the v2 shipment to load pallets for (optional) (default to null)

try:
    api_response = api_instance.select_pallets(v1BatchId=v1BatchId, v2BatchId=v2BatchId, shipmentId=shipmentId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2PalletsApi->selectPallets: %s\n" % e)
extern crate V2PalletsApi;

pub fn main() {
    let v1BatchId = v1BatchId_example; // String
    let v2BatchId = v2BatchId_example; // String
    let shipmentId = shipmentId_example; // String

    let mut context = V2PalletsApi::Context::default();
    let result = client.selectPallets(v1BatchId, v2BatchId, shipmentId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
v1_batch_id
String
The id of the v1 batch to load pallets for
v2_batch_id
String
The id of the v2 batch to load pallets for
shipment_id
String
The id of the v2 shipment to load pallets for

Responses


updatePallet


/api/v2/pallet/{pallet_id}

Usage and SDK Samples

curl -X PATCH \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/v2/pallet/{pallet_id}" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2PalletsApi;

import java.io.File;
import java.util.*;

public class V2PalletsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearer_auth
        HttpBearerAuth bearer_auth = (HttpBearerAuth) defaultClient.getAuthentication("bearer_auth");
        bearer_auth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        V2PalletsApi apiInstance = new V2PalletsApi();
        String palletId = palletId_example; // String | The id of the pallet to update
        V2PalletInput v2PalletInput = ; // V2PalletInput | 

        try {
            insertPallet_200_response result = apiInstance.updatePallet(palletId, v2PalletInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2PalletsApi#updatePallet");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String palletId = new String(); // String | The id of the pallet to update
final V2PalletInput v2PalletInput = new V2PalletInput(); // V2PalletInput | 

try {
    final result = await api_instance.updatePallet(palletId, v2PalletInput);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updatePallet: $e\n');
}

import org.openapitools.client.api.V2PalletsApi;

public class V2PalletsApiExample {
    public static void main(String[] args) {
        V2PalletsApi apiInstance = new V2PalletsApi();
        String palletId = palletId_example; // String | The id of the pallet to update
        V2PalletInput v2PalletInput = ; // V2PalletInput | 

        try {
            insertPallet_200_response result = apiInstance.updatePallet(palletId, v2PalletInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2PalletsApi#updatePallet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearer_auth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
V2PalletsApi *apiInstance = [[V2PalletsApi alloc] init];
String *palletId = palletId_example; // The id of the pallet to update (default to null)
V2PalletInput *v2PalletInput = ; //  (optional)

[apiInstance updatePalletWith:palletId
    v2PalletInput:v2PalletInput
              completionHandler: ^(insertPallet_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearer_auth
var bearer_auth = defaultClient.authentications['bearer_auth'];
bearer_auth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ScanPowerApi.V2PalletsApi()
var palletId = palletId_example; // {String} The id of the pallet to update
var opts = {
  'v2PalletInput':  // {V2PalletInput} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updatePallet(palletId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class updatePalletExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearer_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new V2PalletsApi();
            var palletId = palletId_example;  // String | The id of the pallet to update (default to null)
            var v2PalletInput = new V2PalletInput(); // V2PalletInput |  (optional) 

            try {
                insertPallet_200_response result = apiInstance.updatePallet(palletId, v2PalletInput);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2PalletsApi.updatePallet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer (JWT) access token for authorization: bearer_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2PalletsApi();
$palletId = palletId_example; // String | The id of the pallet to update
$v2PalletInput = ; // V2PalletInput | 

try {
    $result = $api_instance->updatePallet($palletId, $v2PalletInput);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2PalletsApi->updatePallet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2PalletsApi;

# Configure Bearer (JWT) access token for authorization: bearer_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2PalletsApi->new();
my $palletId = palletId_example; # String | The id of the pallet to update
my $v2PalletInput = WWW::OPenAPIClient::Object::V2PalletInput->new(); # V2PalletInput | 

eval {
    my $result = $api_instance->updatePallet(palletId => $palletId, v2PalletInput => $v2PalletInput);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2PalletsApi->updatePallet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: bearer_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.V2PalletsApi()
palletId = palletId_example # String | The id of the pallet to update (default to null)
v2PalletInput =  # V2PalletInput |  (optional)

try:
    api_response = api_instance.update_pallet(palletId, v2PalletInput=v2PalletInput)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2PalletsApi->updatePallet: %s\n" % e)
extern crate V2PalletsApi;

pub fn main() {
    let palletId = palletId_example; // String
    let v2PalletInput = ; // V2PalletInput

    let mut context = V2PalletsApi::Context::default();
    let result = client.updatePallet(palletId, v2PalletInput, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
pallet_id*
String
The id of the pallet to update
Required
Body parameters
Name Description
v2PalletInput

Responses


V2PurchaseOrder

createPurchaseOrder


/api/v2/purchase-order

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/v2/purchase-order" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2PurchaseOrderApi;

import java.io.File;
import java.util.*;

public class V2PurchaseOrderApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearer_auth
        HttpBearerAuth bearer_auth = (HttpBearerAuth) defaultClient.getAuthentication("bearer_auth");
        bearer_auth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        V2PurchaseOrderApi apiInstance = new V2PurchaseOrderApi();
        CreatePurchaseOrderRequest createPurchaseOrderRequest = ; // CreatePurchaseOrderRequest | 

        try {
            createPurchaseOrder_200_response result = apiInstance.createPurchaseOrder(createPurchaseOrderRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2PurchaseOrderApi#createPurchaseOrder");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreatePurchaseOrderRequest createPurchaseOrderRequest = new CreatePurchaseOrderRequest(); // CreatePurchaseOrderRequest | 

try {
    final result = await api_instance.createPurchaseOrder(createPurchaseOrderRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createPurchaseOrder: $e\n');
}

import org.openapitools.client.api.V2PurchaseOrderApi;

public class V2PurchaseOrderApiExample {
    public static void main(String[] args) {
        V2PurchaseOrderApi apiInstance = new V2PurchaseOrderApi();
        CreatePurchaseOrderRequest createPurchaseOrderRequest = ; // CreatePurchaseOrderRequest | 

        try {
            createPurchaseOrder_200_response result = apiInstance.createPurchaseOrder(createPurchaseOrderRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2PurchaseOrderApi#createPurchaseOrder");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearer_auth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
V2PurchaseOrderApi *apiInstance = [[V2PurchaseOrderApi alloc] init];
CreatePurchaseOrderRequest *createPurchaseOrderRequest = ; //  (optional)

[apiInstance createPurchaseOrderWith:createPurchaseOrderRequest
              completionHandler: ^(createPurchaseOrder_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearer_auth
var bearer_auth = defaultClient.authentications['bearer_auth'];
bearer_auth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ScanPowerApi.V2PurchaseOrderApi()
var opts = {
  'createPurchaseOrderRequest':  // {CreatePurchaseOrderRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createPurchaseOrder(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class createPurchaseOrderExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearer_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new V2PurchaseOrderApi();
            var createPurchaseOrderRequest = new CreatePurchaseOrderRequest(); // CreatePurchaseOrderRequest |  (optional) 

            try {
                createPurchaseOrder_200_response result = apiInstance.createPurchaseOrder(createPurchaseOrderRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2PurchaseOrderApi.createPurchaseOrder: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer (JWT) access token for authorization: bearer_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2PurchaseOrderApi();
$createPurchaseOrderRequest = ; // CreatePurchaseOrderRequest | 

try {
    $result = $api_instance->createPurchaseOrder($createPurchaseOrderRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2PurchaseOrderApi->createPurchaseOrder: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2PurchaseOrderApi;

# Configure Bearer (JWT) access token for authorization: bearer_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2PurchaseOrderApi->new();
my $createPurchaseOrderRequest = WWW::OPenAPIClient::Object::CreatePurchaseOrderRequest->new(); # CreatePurchaseOrderRequest | 

eval {
    my $result = $api_instance->createPurchaseOrder(createPurchaseOrderRequest => $createPurchaseOrderRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2PurchaseOrderApi->createPurchaseOrder: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: bearer_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.V2PurchaseOrderApi()
createPurchaseOrderRequest =  # CreatePurchaseOrderRequest |  (optional)

try:
    api_response = api_instance.create_purchase_order(createPurchaseOrderRequest=createPurchaseOrderRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2PurchaseOrderApi->createPurchaseOrder: %s\n" % e)
extern crate V2PurchaseOrderApi;

pub fn main() {
    let createPurchaseOrderRequest = ; // CreatePurchaseOrderRequest

    let mut context = V2PurchaseOrderApi::Context::default();
    let result = client.createPurchaseOrder(createPurchaseOrderRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
createPurchaseOrderRequest

Responses


selectPurchaseOrder


/api/v2/purchase-order/{purchase_order_id}

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/v2/purchase-order/{purchase_order_id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2PurchaseOrderApi;

import java.io.File;
import java.util.*;

public class V2PurchaseOrderApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearer_auth
        HttpBearerAuth bearer_auth = (HttpBearerAuth) defaultClient.getAuthentication("bearer_auth");
        bearer_auth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        V2PurchaseOrderApi apiInstance = new V2PurchaseOrderApi();
        Integer purchaseOrderId = 56; // Integer | 

        try {
            createPurchaseOrder_200_response result = apiInstance.selectPurchaseOrder(purchaseOrderId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2PurchaseOrderApi#selectPurchaseOrder");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer purchaseOrderId = new Integer(); // Integer | 

try {
    final result = await api_instance.selectPurchaseOrder(purchaseOrderId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->selectPurchaseOrder: $e\n');
}

import org.openapitools.client.api.V2PurchaseOrderApi;

public class V2PurchaseOrderApiExample {
    public static void main(String[] args) {
        V2PurchaseOrderApi apiInstance = new V2PurchaseOrderApi();
        Integer purchaseOrderId = 56; // Integer | 

        try {
            createPurchaseOrder_200_response result = apiInstance.selectPurchaseOrder(purchaseOrderId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2PurchaseOrderApi#selectPurchaseOrder");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearer_auth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
V2PurchaseOrderApi *apiInstance = [[V2PurchaseOrderApi alloc] init];
Integer *purchaseOrderId = 56; //  (default to null)

[apiInstance selectPurchaseOrderWith:purchaseOrderId
              completionHandler: ^(createPurchaseOrder_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearer_auth
var bearer_auth = defaultClient.authentications['bearer_auth'];
bearer_auth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ScanPowerApi.V2PurchaseOrderApi()
var purchaseOrderId = 56; // {Integer} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.selectPurchaseOrder(purchaseOrderId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class selectPurchaseOrderExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearer_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new V2PurchaseOrderApi();
            var purchaseOrderId = 56;  // Integer |  (default to null)

            try {
                createPurchaseOrder_200_response result = apiInstance.selectPurchaseOrder(purchaseOrderId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2PurchaseOrderApi.selectPurchaseOrder: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer (JWT) access token for authorization: bearer_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2PurchaseOrderApi();
$purchaseOrderId = 56; // Integer | 

try {
    $result = $api_instance->selectPurchaseOrder($purchaseOrderId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2PurchaseOrderApi->selectPurchaseOrder: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2PurchaseOrderApi;

# Configure Bearer (JWT) access token for authorization: bearer_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2PurchaseOrderApi->new();
my $purchaseOrderId = 56; # Integer | 

eval {
    my $result = $api_instance->selectPurchaseOrder(purchaseOrderId => $purchaseOrderId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2PurchaseOrderApi->selectPurchaseOrder: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: bearer_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.V2PurchaseOrderApi()
purchaseOrderId = 56 # Integer |  (default to null)

try:
    api_response = api_instance.select_purchase_order(purchaseOrderId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2PurchaseOrderApi->selectPurchaseOrder: %s\n" % e)
extern crate V2PurchaseOrderApi;

pub fn main() {
    let purchaseOrderId = 56; // Integer

    let mut context = V2PurchaseOrderApi::Context::default();
    let result = client.selectPurchaseOrder(purchaseOrderId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
purchase_order_id*
Integer
Required

Responses


selectPurchaseOrders


/api/v2/purchase-order

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://unity.scanpower.com/api/v2/purchase-order?archived=true&external_id=externalId_example&offset=56&limit=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2PurchaseOrderApi;

import java.io.File;
import java.util.*;

public class V2PurchaseOrderApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearer_auth
        HttpBearerAuth bearer_auth = (HttpBearerAuth) defaultClient.getAuthentication("bearer_auth");
        bearer_auth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        V2PurchaseOrderApi apiInstance = new V2PurchaseOrderApi();
        Boolean archived = true; // Boolean | Pass `true` to request archived POs
        String externalId = externalId_example; // String | 
        Integer offset = 56; // Integer | An integer offset used for paging
        Integer limit = 56; // Integer | The number of rows to fetch. Defaults to 100

        try {
            selectPurchaseOrders_200_response result = apiInstance.selectPurchaseOrders(archived, externalId, offset, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2PurchaseOrderApi#selectPurchaseOrders");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Boolean archived = new Boolean(); // Boolean | Pass `true` to request archived POs
final String externalId = new String(); // String | 
final Integer offset = new Integer(); // Integer | An integer offset used for paging
final Integer limit = new Integer(); // Integer | The number of rows to fetch. Defaults to 100

try {
    final result = await api_instance.selectPurchaseOrders(archived, externalId, offset, limit);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->selectPurchaseOrders: $e\n');
}

import org.openapitools.client.api.V2PurchaseOrderApi;

public class V2PurchaseOrderApiExample {
    public static void main(String[] args) {
        V2PurchaseOrderApi apiInstance = new V2PurchaseOrderApi();
        Boolean archived = true; // Boolean | Pass `true` to request archived POs
        String externalId = externalId_example; // String | 
        Integer offset = 56; // Integer | An integer offset used for paging
        Integer limit = 56; // Integer | The number of rows to fetch. Defaults to 100

        try {
            selectPurchaseOrders_200_response result = apiInstance.selectPurchaseOrders(archived, externalId, offset, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2PurchaseOrderApi#selectPurchaseOrders");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearer_auth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
V2PurchaseOrderApi *apiInstance = [[V2PurchaseOrderApi alloc] init];
Boolean *archived = true; // Pass `true` to request archived POs (optional) (default to null)
String *externalId = externalId_example; //  (optional) (default to null)
Integer *offset = 56; // An integer offset used for paging (optional) (default to null)
Integer *limit = 56; // The number of rows to fetch. Defaults to 100 (optional) (default to null)

[apiInstance selectPurchaseOrdersWith:archived
    externalId:externalId
    offset:offset
    limit:limit
              completionHandler: ^(selectPurchaseOrders_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearer_auth
var bearer_auth = defaultClient.authentications['bearer_auth'];
bearer_auth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ScanPowerApi.V2PurchaseOrderApi()
var opts = {
  'archived': true, // {Boolean} Pass `true` to request archived POs
  'externalId': externalId_example, // {String} 
  'offset': 56, // {Integer} An integer offset used for paging
  'limit': 56 // {Integer} The number of rows to fetch. Defaults to 100
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.selectPurchaseOrders(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class selectPurchaseOrdersExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearer_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new V2PurchaseOrderApi();
            var archived = true;  // Boolean | Pass `true` to request archived POs (optional)  (default to null)
            var externalId = externalId_example;  // String |  (optional)  (default to null)
            var offset = 56;  // Integer | An integer offset used for paging (optional)  (default to null)
            var limit = 56;  // Integer | The number of rows to fetch. Defaults to 100 (optional)  (default to null)

            try {
                selectPurchaseOrders_200_response result = apiInstance.selectPurchaseOrders(archived, externalId, offset, limit);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2PurchaseOrderApi.selectPurchaseOrders: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer (JWT) access token for authorization: bearer_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2PurchaseOrderApi();
$archived = true; // Boolean | Pass `true` to request archived POs
$externalId = externalId_example; // String | 
$offset = 56; // Integer | An integer offset used for paging
$limit = 56; // Integer | The number of rows to fetch. Defaults to 100

try {
    $result = $api_instance->selectPurchaseOrders($archived, $externalId, $offset, $limit);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2PurchaseOrderApi->selectPurchaseOrders: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2PurchaseOrderApi;

# Configure Bearer (JWT) access token for authorization: bearer_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2PurchaseOrderApi->new();
my $archived = true; # Boolean | Pass `true` to request archived POs
my $externalId = externalId_example; # String | 
my $offset = 56; # Integer | An integer offset used for paging
my $limit = 56; # Integer | The number of rows to fetch. Defaults to 100

eval {
    my $result = $api_instance->selectPurchaseOrders(archived => $archived, externalId => $externalId, offset => $offset, limit => $limit);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2PurchaseOrderApi->selectPurchaseOrders: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: bearer_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.V2PurchaseOrderApi()
archived = true # Boolean | Pass `true` to request archived POs (optional) (default to null)
externalId = externalId_example # String |  (optional) (default to null)
offset = 56 # Integer | An integer offset used for paging (optional) (default to null)
limit = 56 # Integer | The number of rows to fetch. Defaults to 100 (optional) (default to null)

try:
    api_response = api_instance.select_purchase_orders(archived=archived, externalId=externalId, offset=offset, limit=limit)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2PurchaseOrderApi->selectPurchaseOrders: %s\n" % e)
extern crate V2PurchaseOrderApi;

pub fn main() {
    let archived = true; // Boolean
    let externalId = externalId_example; // String
    let offset = 56; // Integer
    let limit = 56; // Integer

    let mut context = V2PurchaseOrderApi::Context::default();
    let result = client.selectPurchaseOrders(archived, externalId, offset, limit, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
archived
Boolean
Pass `true` to request archived POs
external_id
String
offset
Integer
An integer offset used for paging
limit
Integer
The number of rows to fetch. Defaults to 100

Responses


updatePurchaseOrder


/api/v2/purchase-order/{purchase_order_id}

Usage and SDK Samples

curl -X PATCH \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://unity.scanpower.com/api/v2/purchase-order/{purchase_order_id}" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.V2PurchaseOrderApi;

import java.io.File;
import java.util.*;

public class V2PurchaseOrderApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearer_auth
        HttpBearerAuth bearer_auth = (HttpBearerAuth) defaultClient.getAuthentication("bearer_auth");
        bearer_auth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        V2PurchaseOrderApi apiInstance = new V2PurchaseOrderApi();
        Integer purchaseOrderId = 56; // Integer | 
        UpdatePurchaseOrderRequest updatePurchaseOrderRequest = ; // UpdatePurchaseOrderRequest | 

        try {
            createPurchaseOrder_200_response result = apiInstance.updatePurchaseOrder(purchaseOrderId, updatePurchaseOrderRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2PurchaseOrderApi#updatePurchaseOrder");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer purchaseOrderId = new Integer(); // Integer | 
final UpdatePurchaseOrderRequest updatePurchaseOrderRequest = new UpdatePurchaseOrderRequest(); // UpdatePurchaseOrderRequest | 

try {
    final result = await api_instance.updatePurchaseOrder(purchaseOrderId, updatePurchaseOrderRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updatePurchaseOrder: $e\n');
}

import org.openapitools.client.api.V2PurchaseOrderApi;

public class V2PurchaseOrderApiExample {
    public static void main(String[] args) {
        V2PurchaseOrderApi apiInstance = new V2PurchaseOrderApi();
        Integer purchaseOrderId = 56; // Integer | 
        UpdatePurchaseOrderRequest updatePurchaseOrderRequest = ; // UpdatePurchaseOrderRequest | 

        try {
            createPurchaseOrder_200_response result = apiInstance.updatePurchaseOrder(purchaseOrderId, updatePurchaseOrderRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling V2PurchaseOrderApi#updatePurchaseOrder");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearer_auth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
V2PurchaseOrderApi *apiInstance = [[V2PurchaseOrderApi alloc] init];
Integer *purchaseOrderId = 56; //  (default to null)
UpdatePurchaseOrderRequest *updatePurchaseOrderRequest = ; //  (optional)

[apiInstance updatePurchaseOrderWith:purchaseOrderId
    updatePurchaseOrderRequest:updatePurchaseOrderRequest
              completionHandler: ^(createPurchaseOrder_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScanPowerApi = require('scan_power_api');
var defaultClient = ScanPowerApi.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearer_auth
var bearer_auth = defaultClient.authentications['bearer_auth'];
bearer_auth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new ScanPowerApi.V2PurchaseOrderApi()
var purchaseOrderId = 56; // {Integer} 
var opts = {
  'updatePurchaseOrderRequest':  // {UpdatePurchaseOrderRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updatePurchaseOrder(purchaseOrderId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class updatePurchaseOrderExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearer_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new V2PurchaseOrderApi();
            var purchaseOrderId = 56;  // Integer |  (default to null)
            var updatePurchaseOrderRequest = new UpdatePurchaseOrderRequest(); // UpdatePurchaseOrderRequest |  (optional) 

            try {
                createPurchaseOrder_200_response result = apiInstance.updatePurchaseOrder(purchaseOrderId, updatePurchaseOrderRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling V2PurchaseOrderApi.updatePurchaseOrder: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer (JWT) access token for authorization: bearer_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\V2PurchaseOrderApi();
$purchaseOrderId = 56; // Integer | 
$updatePurchaseOrderRequest = ; // UpdatePurchaseOrderRequest | 

try {
    $result = $api_instance->updatePurchaseOrder($purchaseOrderId, $updatePurchaseOrderRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling V2PurchaseOrderApi->updatePurchaseOrder: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::V2PurchaseOrderApi;

# Configure Bearer (JWT) access token for authorization: bearer_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::V2PurchaseOrderApi->new();
my $purchaseOrderId = 56; # Integer | 
my $updatePurchaseOrderRequest = WWW::OPenAPIClient::Object::UpdatePurchaseOrderRequest->new(); # UpdatePurchaseOrderRequest | 

eval {
    my $result = $api_instance->updatePurchaseOrder(purchaseOrderId => $purchaseOrderId, updatePurchaseOrderRequest => $updatePurchaseOrderRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling V2PurchaseOrderApi->updatePurchaseOrder: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer (JWT) access token for authorization: bearer_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.V2PurchaseOrderApi()
purchaseOrderId = 56 # Integer |  (default to null)
updatePurchaseOrderRequest =  # UpdatePurchaseOrderRequest |  (optional)

try:
    api_response = api_instance.update_purchase_order(purchaseOrderId, updatePurchaseOrderRequest=updatePurchaseOrderRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling V2PurchaseOrderApi->updatePurchaseOrder: %s\n" % e)
extern crate V2PurchaseOrderApi;

pub fn main() {
    let purchaseOrderId = 56; // Integer
    let updatePurchaseOrderRequest = ; // UpdatePurchaseOrderRequest

    let mut context = V2PurchaseOrderApi::Context::default();
    let result = client.updatePurchaseOrder(purchaseOrderId, updatePurchaseOrderRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
purchase_order_id*
Integer
Required
Body parameters
Name Description
updatePurchaseOrderRequest

Responses